diff options
79 files changed, 5970 insertions, 2521 deletions
@@ -640,6 +640,8 @@ PHP 8.0 UPGRADE NOTES RFC: https://wiki.php.net/rfc/inheritance_private_methods . Added support for nullsafe operator (`?->`). RFC: https://wiki.php.net/rfc/nullsafe_operator + . Added support for named arguments. + RFC: https://wiki.php.net/rfc/named_params - Date: . Added DateTime::createFromInterface() and diff --git a/Zend/tests/arg_unpack/non_integer_keys.phpt b/Zend/tests/arg_unpack/non_integer_keys.phpt index 6b73efa416..88e1747df9 100644 --- a/Zend/tests/arg_unpack/non_integer_keys.phpt +++ b/Zend/tests/arg_unpack/non_integer_keys.phpt @@ -18,4 +18,4 @@ try { ?> --EXPECT-- -Exception: Cannot unpack Traversable with non-integer keys +Exception: Keys must be of type int|string during argument unpacking diff --git a/Zend/tests/arg_unpack/string_keys.phpt b/Zend/tests/arg_unpack/string_keys.phpt index 7b620b0830..b0bf366fb3 100644 --- a/Zend/tests/arg_unpack/string_keys.phpt +++ b/Zend/tests/arg_unpack/string_keys.phpt @@ -8,11 +8,6 @@ set_error_handler(function($errno, $errstr) { }); try { - var_dump(...[1, 2, "foo" => 3, 4]); -} catch (Error $ex) { - var_dump($ex->getMessage()); -} -try { var_dump(...new ArrayIterator([1, 2, "foo" => 3, 4])); } catch (Error $ex) { var_dump($ex->getMessage()); @@ -20,5 +15,4 @@ try { ?> --EXPECT-- -string(36) "Cannot unpack array with string keys" -string(42) "Cannot unpack Traversable with string keys" +string(68) "Cannot use positional argument after named argument during unpacking" diff --git a/Zend/tests/assert/expect_015.phpt b/Zend/tests/assert/expect_015.phpt index ac67780730..ed1b442d6e 100644 --- a/Zend/tests/assert/expect_015.phpt +++ b/Zend/tests/assert/expect_015.phpt @@ -60,6 +60,7 @@ assert(0 && ($a = function &(array &$a, ?X $b = null) use ($c,&$d) : ?X { $x = C::${$z . "_1"}; $x?->y; $x?->y(); + foo(bar: $x); } } })); @@ -202,6 +203,7 @@ Warning: assert(): assert(0 && ($a = function &(array &$a, ?X $b = null) use($c, $x = C::${$z . '_1'}; $x?->y; $x?->y(); + foo(bar: $x); } } diff --git a/Zend/tests/bug43343.phpt b/Zend/tests/bug43343.phpt index c277ccccdd..748562e985 100644 --- a/Zend/tests/bug43343.phpt +++ b/Zend/tests/bug43343.phpt @@ -8,4 +8,4 @@ $foo = 'bar'; var_dump(new namespace::$foo); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "namespace" in %s on line %d +Parse error: syntax error, unexpected token "namespace", expecting ":" in %s on line %d diff --git a/Zend/tests/named_params/__call.phpt b/Zend/tests/named_params/__call.phpt new file mode 100644 index 0000000000..a5ebdc2338 --- /dev/null +++ b/Zend/tests/named_params/__call.phpt @@ -0,0 +1,37 @@ +--TEST-- +Check that __call() and __callStatic() work with named parameters +--FILE-- +<?php + +class Test { + public function __call(string $method, array $args) { + $this->{'_'.$method}(...$args); + } + + public static function __callStatic(string $method, array $args) { + (new static)->{'_'.$method}(...$args); + } + + private function _method($a = 'a', $b = 'b') { + echo "a: $a, b: $b\n"; + } +} + +$obj = new class { public function __toString() { return "STR"; } }; + +$test = new Test; +$test->method(a: 'A', b: 'B'); +$test->method(b: 'B'); +$test->method(b: $obj); +Test::method(a: 'A', b: 'B'); +Test::method(b: 'B'); +Test::method(b: $obj); + +?> +--EXPECT-- +a: A, b: B +a: a, b: B +a: a, b: STR +a: A, b: B +a: a, b: B +a: a, b: STR diff --git a/Zend/tests/named_params/__invoke.phpt b/Zend/tests/named_params/__invoke.phpt new file mode 100644 index 0000000000..6ebbac0f07 --- /dev/null +++ b/Zend/tests/named_params/__invoke.phpt @@ -0,0 +1,64 @@ +--TEST-- +Check that __invoke() works with named parameters +--FILE-- +<?php + +class Test { + public function __invoke($a = 'a', $b = 'b') { + echo "a: $a, b: $b\n"; + } +} + +class Test2 { + public function __invoke($a = 'a', $b = 'b', ...$rest) { + echo "a: $a, b: $b\n"; + var_dump($rest); + } +} + +$test = new Test; +$test(b: 'B', a: 'A'); +$test(b: 'B'); +try { + $test(b: 'B', c: 'C'); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} +echo "\n"; + +$test2 = new Test2; +$test2(b: 'B', a: 'A', c: 'C'); +$test2(b: 'B', c: 'C'); +echo "\n"; + +$test3 = function($a = 'a', $b = 'b') { + echo "a: $a, b: $b\n"; +}; +$test3(b: 'B', a: 'A'); +$test3(b: 'B'); +try { + $test3(b: 'B', c: 'C'); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +a: A, b: B +a: a, b: B +Unknown named parameter $c + +a: A, b: B +array(1) { + ["c"]=> + string(1) "C" +} +a: a, b: B +array(1) { + ["c"]=> + string(1) "C" +} + +a: A, b: B +a: a, b: B +Unknown named parameter $c diff --git a/Zend/tests/named_params/attributes.phpt b/Zend/tests/named_params/attributes.phpt new file mode 100644 index 0000000000..931dbfbe9f --- /dev/null +++ b/Zend/tests/named_params/attributes.phpt @@ -0,0 +1,50 @@ +--TEST-- +Named params in attributes +--FILE-- +<?php + +@@Attribute +class MyAttribute { + public function __construct( + public $a = 'a', + public $b = 'b', + public $c = 'c', + ) {} +} + +@@MyAttribute('A', c: 'C') +class Test1 {} + +@@MyAttribute('A', a: 'C') +class Test2 {} + +$attr = (new ReflectionClass(Test1::class))->getAttributes()[0]; +var_dump($attr->getName()); +var_dump($attr->getArguments()); +var_dump($attr->newInstance()); + +$attr = (new ReflectionClass(Test2::class))->getAttributes()[0]; +try { + var_dump($attr->newInstance()); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +string(11) "MyAttribute" +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} +object(MyAttribute)#1 (3) { + ["a"]=> + string(1) "A" + ["b"]=> + string(1) "b" + ["c"]=> + string(1) "C" +} +Named parameter $a overwrites previous argument diff --git a/Zend/tests/named_params/attributes_duplicate_named_param.phpt b/Zend/tests/named_params/attributes_duplicate_named_param.phpt new file mode 100644 index 0000000000..bcd9f9b717 --- /dev/null +++ b/Zend/tests/named_params/attributes_duplicate_named_param.phpt @@ -0,0 +1,11 @@ +--TEST-- +Named params in attributes: Duplicate named parameter error +--FILE-- +<?php + +@@MyAttribute(a: 'A', a: 'A') +class Test {} + +?> +--EXPECTF-- +Fatal error: Duplicate named parameter $a in %s on line %d diff --git a/Zend/tests/named_params/attributes_named_flags.phpt b/Zend/tests/named_params/attributes_named_flags.phpt new file mode 100644 index 0000000000..f553aa5308 --- /dev/null +++ b/Zend/tests/named_params/attributes_named_flags.phpt @@ -0,0 +1,21 @@ +--TEST-- +Named flags parameter for Attribute attribute +--FILE-- +<?php + +@@Attribute(flags: Attribute::TARGET_CLASS) +class MyAttribute { +} + +@@MyAttribute +function test() {} + +(new ReflectionFunction('test'))->getAttributes()[0]->newInstance(); + +?> +--EXPECTF-- +Fatal error: Uncaught Error: Attribute "MyAttribute" cannot target function (allowed targets: class) in %s:%d +Stack trace: +#0 %s(%d): ReflectionAttribute->newInstance() +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/named_params/attributes_named_flags_incorrect.phpt b/Zend/tests/named_params/attributes_named_flags_incorrect.phpt new file mode 100644 index 0000000000..6f5b226157 --- /dev/null +++ b/Zend/tests/named_params/attributes_named_flags_incorrect.phpt @@ -0,0 +1,22 @@ +--TEST-- +Named flags parameter for Attribute attribute (incorrect parameter name) +--FILE-- +<?php + +// TODO: This should error at compile-time. +@@Attribute(not_flags: Attribute::TARGET_CLASS) +class MyAttribute { +} + +@@MyAttribute +function test() {} + +(new ReflectionFunction('test'))->getAttributes()[0]->newInstance(); + +?> +--EXPECTF-- +Fatal error: Uncaught Error: Attribute "MyAttribute" cannot target function (allowed targets: class) in %s:%d +Stack trace: +#0 %s(%d): ReflectionAttribute->newInstance() +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/named_params/attributes_positional_after_named.phpt b/Zend/tests/named_params/attributes_positional_after_named.phpt new file mode 100644 index 0000000000..61cee4dc1f --- /dev/null +++ b/Zend/tests/named_params/attributes_positional_after_named.phpt @@ -0,0 +1,14 @@ +--TEST-- +Named params in attributes: Positional after named error +--FILE-- +<?php + +@@Attribute +class MyAttribute { } + +@@MyAttribute(a: 'A', 'B') +class Test {} + +?> +--EXPECTF-- +Fatal error: Cannot use positional argument after named argument in %s on line %d diff --git a/Zend/tests/named_params/backtrace.phpt b/Zend/tests/named_params/backtrace.phpt new file mode 100644 index 0000000000..1ccae8503d --- /dev/null +++ b/Zend/tests/named_params/backtrace.phpt @@ -0,0 +1,69 @@ +--TEST-- +Extra named params in backtraces +--FILE-- +<?php + +function test($a, ...$rest) { + var_dump(debug_backtrace()); + debug_print_backtrace(); + throw new Exception("Test"); +} + +try { + test(1, 2, x: 3, y: 4); +} catch (Exception $e) { + var_dump($e->getTrace()); + echo $e, "\n"; +} + +?> +--EXPECTF-- +array(1) { + [0]=> + array(4) { + ["file"]=> + string(%d) "%s" + ["line"]=> + int(10) + ["function"]=> + string(4) "test" + ["args"]=> + array(4) { + [0]=> + int(1) + [1]=> + int(2) + ["x"]=> + int(3) + ["y"]=> + int(4) + } + } +} +#0 test(1, 2, x: 3, y: 4) called at [%s:10] +array(1) { + [0]=> + array(4) { + ["file"]=> + string(%d) "%s" + ["line"]=> + int(10) + ["function"]=> + string(4) "test" + ["args"]=> + array(4) { + [0]=> + int(1) + [1]=> + int(2) + ["x"]=> + int(3) + ["y"]=> + int(4) + } + } +} +Exception: Test in %s:%d +Stack trace: +#0 %s(%d): test(1, 2, x: 3, y: 4) +#1 {main} diff --git a/Zend/tests/named_params/basic.phpt b/Zend/tests/named_params/basic.phpt new file mode 100644 index 0000000000..4ad187d255 --- /dev/null +++ b/Zend/tests/named_params/basic.phpt @@ -0,0 +1,106 @@ +--TEST-- +Basic test +--FILE-- +<?php + +function test($a, $b, $c = "c", $d = "d", $e = "e") { + echo "a=$a, b=$b, c=$c, d=$d, e=$e\n"; +} + +function test3(&$a, &$b, &$c = "c", &$d = "d", &$e = "e") { + echo "a=$a, b=$b, c=$c, d=$d, e=$e\n"; +} + +function &id($x) { + return $x; +} + +$a = "A"; $b = "B"; $c = "C"; $d = "D"; $e = "E"; + +echo "SEND_VAL:\n"; +test("A", "B", "C", d: "D", e: "E"); +test("A", "B", "C", e: "E", d: "D"); +test(e: "E", a: "A", d: "D", b: "B", c: "C"); +test("A", "B", "C", e: "E"); + +echo "SEND_VAL_EX:\n"; +test2("A", "B", "C", d: "D", e: "E"); +test2("A", "B", "C", e: "E", d: "D"); +test2(e: "E", a: "A", d: "D", b: "B", c: "C"); +test2("A", "B", "C", e: "E"); + +echo "SEND_VAR:\n"; +test($a, $b, $c, d: $d, e: $e); +test($a, $b, $c, e: $e, d: $d); +test(e: $e, a: $a, d: $d, b: $b, c: $c); +test(a: $a, b: $b, c: $c, e: $e); + +echo "SEND_VAR_EX:\n"; +test2($a, $b, $c, d: $d, e: $e); +test2($a, $b, $c, e: $e, d: $d); +test2(e: $e, a: $a, d: $d, b: $b, c: $c); +test2(a: $a, b: $b, c: $c, e: $e); + +echo "SEND_VAR_NO_REF:\n"; +test3(id("A"), id("B"), id("C"), d: id("D"), e: id("E")); +test3(id("A"), id("B"), id("C"), e: id("E"), d: id("D")); +test3(e: id("E"), a: id("A"), d: id("D"), b: id("B"), c: id("C")); +test3(id("A"), id("B"), id("C"), e: id("E")); + +echo "SEND_VAR_NO_REF_EX:\n"; +test4(id("A"), id("B"), id("C"), d: id("D"), e: id("E")); +test4(id("A"), id("B"), id("C"), e: id("E"), d: id("D")); +test4(e: id("E"), a: id("A"), d: id("D"), b: id("B"), c: id("C")); +test4(id("A"), id("B"), id("C"), e: id("E")); + +echo "SEND_REF:\n"; +test3($a, $b, $c, d: $d, e: $e); +test3($a, $b, $c, e: $e, d: $d); +test3(e: $e, a: $a, d: $d, b: $b, c: $c); +test3(a: $a, b: $b, c: $c, e: $e); + +function test2($a, $b, $c = "c", $d = "d", $e = "e") { + echo "a=$a, b=$b, c=$c, d=$d, e=$e\n"; +} + +function test4(&$a, &$b, &$c = "c", &$d = "d", &$e = "e") { + echo "a=$a, b=$b, c=$c, d=$d, e=$e\n"; +} + +?> +--EXPECT-- +SEND_VAL: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_VAL_EX: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_VAR: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_VAR_EX: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_VAR_NO_REF: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_VAR_NO_REF_EX: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E +SEND_REF: +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=D, e=E +a=A, b=B, c=C, d=d, e=E diff --git a/Zend/tests/named_params/call_user_func.phpt b/Zend/tests/named_params/call_user_func.phpt new file mode 100644 index 0000000000..5a11dfd20d --- /dev/null +++ b/Zend/tests/named_params/call_user_func.phpt @@ -0,0 +1,105 @@ +--TEST-- +call_user_func() and friends with named parameters +--FILE-- +<?php + +$test = function($a = 'a', $b = 'b', $c = 'c') { + echo "a = $a, b = $b, c = $c\n"; +}; +$test_variadic = function(...$args) { + var_dump($args); +}; +$test_ref = function(&$ref) { + $ref++; +}; + +class Test { + public function __construct($a = 'a', $b = 'b', $c = 'c') { + if (func_num_args() != 0) { + echo "a = $a, b = $b, c = $c\n"; + } + } + + public function method($a = 'a', $b = 'b', $c = 'c') { + echo "a = $a, b = $b, c = $c\n"; + } +} + +call_user_func($test, 'A', c: 'C'); +call_user_func($test, c: 'C', a: 'A'); +call_user_func($test, c: 'C'); +call_user_func($test_variadic, 'A', c: 'C'); +call_user_func($test_ref, ref: null); +var_dump(call_user_func('call_user_func', $test, c: 'D')); +try { + var_dump(call_user_func('array_slice', [1, 2, 3, 4, 5], length: 2)); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} +try { + var_dump(call_user_func('array_slice', [1, 2, 3, 4, 'x' => 5], 3, preserve_keys: true)); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} +echo "\n"; + +$test->__invoke('A', c: 'C'); +$test_variadic->__invoke('A', c: 'C'); +$test->call(new class {}, 'A', c: 'C'); +$test_variadic->call(new class {}, 'A', c: 'C'); +echo "\n"; + +$rf = new ReflectionFunction($test); +$rf->invoke('A', c: 'C'); +$rf->invokeArgs(['A', 'c' => 'C']); +$rm = new ReflectionMethod(Test::class, 'method'); +$rm->invoke(new Test, 'A', c: 'C'); +$rm->invokeArgs(new Test, ['A', 'c' => 'C']); +$rc = new ReflectionClass(Test::class); +$rc->newInstance('A', c: 'C'); +$rc->newInstanceArgs(['A', 'c' => 'C']); + +?> +--EXPECTF-- +a = A, b = b, c = C +a = A, b = b, c = C +a = a, b = b, c = C +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} + +Warning: {closure}(): Argument #1 ($ref) must be passed by reference, value given in %s on line %d +a = a, b = b, c = D +NULL +array_slice(): Argument #2 ($offset) not passed +array(2) { + [3]=> + int(4) + ["x"]=> + int(5) +} + +a = A, b = b, c = C +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} +a = A, b = b, c = C +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} + +a = A, b = b, c = C +a = A, b = b, c = C +a = A, b = b, c = C +a = A, b = b, c = C +a = A, b = b, c = C +a = A, b = b, c = C diff --git a/Zend/tests/named_params/call_user_func_array.phpt b/Zend/tests/named_params/call_user_func_array.phpt new file mode 100644 index 0000000000..ebee06ea6a --- /dev/null +++ b/Zend/tests/named_params/call_user_func_array.phpt @@ -0,0 +1,72 @@ +--TEST-- +Behavior of call_user_func_array() with named parameters +--FILE-- +<?php + +namespace { + $test = function($a = 'a', $b = 'b', $c = 'c') { + echo "a = $a, b = $b, c = $c\n"; + }; + $test_variadic = function(...$args) { + var_dump($args); + }; + + call_user_func_array($test, ['A', 'B']); + call_user_func_array($test, [1 => 'A', 0 => 'B']); + call_user_func_array($test, ['A', 'c' => 'C']); + call_user_func_array($test_variadic, ['A', 'c' => 'C']); + try { + call_user_func_array($test, ['d' => 'D']); + } catch (\Error $e) { + echo $e->getMessage(), "\n"; + } + try { + call_user_func_array($test, ['c' => 'C', 'A']); + } catch (\Error $e) { + echo $e->getMessage(), "\n"; + } + echo "\n"; +} + +namespace Foo { + call_user_func_array($test, ['A', 'B']); + call_user_func_array($test, [1 => 'A', 0 => 'B']); + call_user_func_array($test, ['A', 'c' => 'C']); + call_user_func_array($test_variadic, ['A', 'c' => 'C']); + try { + call_user_func_array($test, ['d' => 'D']); + } catch (\Error $e) { + echo $e->getMessage(), "\n"; + } + try { + call_user_func_array($test, ['c' => 'C', 'A']); + } catch (\Error $e) { + echo $e->getMessage(), "\n"; + } +} + +?> +--EXPECT-- +a = A, b = B, c = c +a = A, b = B, c = c +a = A, b = b, c = C +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} +Unknown named parameter $d +Cannot use positional argument after named argument + +a = A, b = B, c = c +a = A, b = B, c = c +a = A, b = b, c = C +array(2) { + [0]=> + string(1) "A" + ["c"]=> + string(1) "C" +} +Unknown named parameter $d +Cannot use positional argument after named argument diff --git a/Zend/tests/named_params/defaults.phpt b/Zend/tests/named_params/defaults.phpt new file mode 100644 index 0000000000..23f2cab92d --- /dev/null +++ b/Zend/tests/named_params/defaults.phpt @@ -0,0 +1,35 @@ +--TEST-- +Skipping over default parameters +--FILE-- +<?php + +function test1($a = 'a', $b = 'b') { + echo "a: $a, b: $b\n"; +} + +function test2($a = SOME_CONST, $b = 'b') { + echo "a: $a, b: $b\n"; +} + +function test3($a = SOME_OTHER_CONST, $b = 'b') { + echo "a: $a, b: $b\n"; +} + +test1(b: 'B'); + +define('SOME_CONST', 'X'); +test2(b: 'B'); + +// NB: We also want to test the stack trace. +test3(b: 'B'); + +?> +--EXPECTF-- +a: a, b: B +a: X, b: B + +Fatal error: Uncaught Error: Undefined constant "SOME_OTHER_CONST" in %s:%d +Stack trace: +#0 %s(%d): test3(NULL, 'B') +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/named_params/duplicate_param.phpt b/Zend/tests/named_params/duplicate_param.phpt new file mode 100644 index 0000000000..6abc95bba0 --- /dev/null +++ b/Zend/tests/named_params/duplicate_param.phpt @@ -0,0 +1,23 @@ +--TEST-- +Duplicate param +--FILE-- +<?php + +function test($a) {} + +try { + test(a: 1, a: 2); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + test(1, a: 2); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Named parameter $a overwrites previous argument +Named parameter $a overwrites previous argument diff --git a/Zend/tests/named_params/func_get_args.phpt b/Zend/tests/named_params/func_get_args.phpt new file mode 100644 index 0000000000..a33f45229d --- /dev/null +++ b/Zend/tests/named_params/func_get_args.phpt @@ -0,0 +1,29 @@ +--TEST-- +Behavior of func_get_args() and friends with named parameters +--FILE-- +<?php + +function test($a, $b = 'b', $c = 'c') { + var_dump(func_num_args()); + var_dump(func_get_args()); + var_dump(func_get_arg(0)); + var_dump(func_get_arg(1)); + var_dump(func_get_arg(2)); +} + +test(c: 'C', a: 'A'); + +?> +--EXPECT-- +int(3) +array(3) { + [0]=> + string(1) "A" + [1]=> + string(1) "b" + [2]=> + string(1) "C" +} +string(1) "A" +string(1) "b" +string(1) "C" diff --git a/Zend/tests/named_params/internal.phpt b/Zend/tests/named_params/internal.phpt new file mode 100644 index 0000000000..97260c2564 --- /dev/null +++ b/Zend/tests/named_params/internal.phpt @@ -0,0 +1,39 @@ +--TEST-- +Named params on internal functions +--FILE-- +<?php + +var_dump(array_slice(arg: [1, 2, 3, 4, 5], offset: 2, length: 2)); +var_dump(array_slice(length: 2, offset: 2, arg: [1, 2, 3, 4, 5])); + +var_dump(array_slice(arg: ['a' => 0, 'b' => 1], offset: 1, preserve_keys: true)); +var_dump(array_slice(['a' => 0, 'b' => 1], preserve_keys: true, offset: 1)); +var_dump(str_pad("foo", 6, pad_type: STR_PAD_LEFT)); + +// Named params work with specialized functions. +var_dump(strlen(string: 'foo')); + +?> +--EXPECT-- +array(2) { + [0]=> + int(3) + [1]=> + int(4) +} +array(2) { + [0]=> + int(3) + [1]=> + int(4) +} +array(1) { + ["b"]=> + int(1) +} +array(1) { + ["b"]=> + int(1) +} +string(6) " foo" +int(3) diff --git a/Zend/tests/named_params/internal_variadics.phpt b/Zend/tests/named_params/internal_variadics.phpt new file mode 100644 index 0000000000..3599f644ac --- /dev/null +++ b/Zend/tests/named_params/internal_variadics.phpt @@ -0,0 +1,21 @@ +--TEST-- +Named params on internal functions: Variadic functions that don't support extra named args +--FILE-- +<?php + +try { + array_merge([1, 2], a: [3, 4]); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} + +try { + array_diff_key([1, 2], [3, 4], a: [5, 6]); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +array_merge() does not accept unknown named parameters +array_diff_key() does not accept unknown named parameters diff --git a/Zend/tests/named_params/missing_param.phpt b/Zend/tests/named_params/missing_param.phpt new file mode 100644 index 0000000000..52dc1b1a54 --- /dev/null +++ b/Zend/tests/named_params/missing_param.phpt @@ -0,0 +1,38 @@ +--TEST-- +Required parameter not passed +--FILE-- +<?php + +function test($a, $b, $c, $d) { +} + +try { + test(a: 'a', d: 'd'); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} + +try { + array_keys(strict: true); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} + +try { + array_keys([], strict: true); +} catch (ArgumentCountError $e) { + echo $e->getMessage(), "\n"; +} + +// This works fine, as search_value is explicitly specified. +var_dump(array_keys([41, 42], search_value: 42, strict: true)); + +?> +--EXPECT-- +test(): Argument #2 ($b) not passed +array_keys(): Argument #1 ($arg) not passed +array_keys(): Argument #2 ($search_value) must be passed explicitly, because the default value is not known +array(1) { + [0]=> + int(1) +} diff --git a/Zend/tests/named_params/positional_after_named.phpt b/Zend/tests/named_params/positional_after_named.phpt new file mode 100644 index 0000000000..a415df55ec --- /dev/null +++ b/Zend/tests/named_params/positional_after_named.phpt @@ -0,0 +1,10 @@ +--TEST-- +Cannot used positional parameter after named parameter +--FILE-- +<?php + +test(a: 1, 2); + +?> +--EXPECTF-- +Fatal error: Cannot use positional argument after named argument in %s on line %d diff --git a/Zend/tests/named_params/references.phpt b/Zend/tests/named_params/references.phpt new file mode 100644 index 0000000000..aa3689b5e0 --- /dev/null +++ b/Zend/tests/named_params/references.phpt @@ -0,0 +1,39 @@ +--TEST-- +Check that reference detection works properly +--FILE-- +<?php + +$v00 = $v01 = $v32 = $v33 = 0; +test(p32: $v32, p33: $v33, p00: $v00, p01: $v01); +echo "$v00 $v01 $v32 $v33\n"; + +$v = [0 => 0, 1 => 0, 32 => 0, 33 => 0]; +test(p32: $v[32], p33: $v[33], p00: $v[0], p01: $v[1]); +echo "$v[0] $v[1] $v[32] $v[33]\n"; + +function test( + &$p00 = null, $p01 = null, &$p02 = null, $p03 = null, &$p04 = null, $p05 = null, + &$p06 = null, $p07 = null, &$p08 = null, $p09 = null, &$p10 = null, $p11 = null, + &$p12 = null, $p13 = null, &$p14 = null, $p15 = null, &$p16 = null, $p17 = null, + &$p18 = null, $p19 = null, &$p20 = null, $p21 = null, &$p22 = null, $p23 = null, + &$p24 = null, $p25 = null, &$p26 = null, $p27 = null, &$p28 = null, $p29 = null, + &$p30 = null, $p31 = null, &$p32 = null, $p33 = null, &$p34 = null, $p35 = null +) { + $p00++; + $p32++; +} + +$v00 = $v01 = $v32 = $v33 = 0; +test(p32: $v32, p33: $v33, p00: $v00, p01: $v01); +echo "$v00 $v01 $v32 $v33\n"; + +$v = [0 => 0, 1 => 0, 32 => 0, 33 => 0]; +test(p32: $v[32], p33: $v[33], p00: $v[0], p01: $v[1]); +echo "$v[0] $v[1] $v[32] $v[33]\n"; + +?> +--EXPECT-- +1 0 1 0 +1 0 1 0 +1 0 1 0 +1 0 1 0 diff --git a/Zend/tests/named_params/reserved.phpt b/Zend/tests/named_params/reserved.phpt new file mode 100644 index 0000000000..93ae470569 --- /dev/null +++ b/Zend/tests/named_params/reserved.phpt @@ -0,0 +1,15 @@ +--TEST-- +Reserved keywords can be used with named parameters +--FILE-- +<?php + +function test($array) { + var_dump($array); +} + +test(array: []); + +?> +--EXPECT-- +array(0) { +} diff --git a/Zend/tests/named_params/unknown_named_param.phpt b/Zend/tests/named_params/unknown_named_param.phpt new file mode 100644 index 0000000000..f43a40c69c --- /dev/null +++ b/Zend/tests/named_params/unknown_named_param.phpt @@ -0,0 +1,26 @@ +--TEST-- +Unknown named parameter +--FILE-- +<?php + +function test($a) { +} + +function test2(...$a) { +} + +try { + test(b: 42); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + test2(a: 42); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Unknown named parameter $b diff --git a/Zend/tests/named_params/unpack.phpt b/Zend/tests/named_params/unpack.phpt new file mode 100644 index 0000000000..92bb4792c3 --- /dev/null +++ b/Zend/tests/named_params/unpack.phpt @@ -0,0 +1,85 @@ +--TEST-- +Unpacking named parameters +--FILE-- +<?php + +function test($a, $b, $c) { + echo "a = $a, b = $b, c = $c\n"; +} + +function test2($a = null, &$b = null) { + $b++; +} + +test(...['a' => 'a', 'b' => 'b', 'c' => 'c']); +test(...['c' => 'c', 'b' => 'b', 'a' => 'a']); +test(...['a', 'b' => 'b', 'c' => 'c']); + +try { + test(...['a', 'b' => 'b', 'c']); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + test(...['a', 'a' => 'a']); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +$ary = ['b' => 0]; +$ary2 = $ary; +test2(...$ary); +var_dump($ary, $ary2); + +test(...new ArrayIterator(['a' => 'a', 'b' => 'b', 'c' => 'c'])); +test(...new ArrayIterator(['c' => 'c', 'b' => 'b', 'a' => 'a'])); +test(...new ArrayIterator(['a', 'b' => 'b', 'c' => 'c'])); + +try { + test(...new ArrayIterator(['a', 'b' => 'b', 'c'])); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + test(...new ArrayIterator(['a', 'a' => 'a'])); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +$ary = ['b' => 0]; +$ary2 = $ary; +test2(...new ArrayIterator($ary)); +var_dump($ary, $ary2); + +?> +--EXPECTF-- +a = a, b = b, c = c +a = a, b = b, c = c +a = a, b = b, c = c +Cannot use positional argument after named argument during unpacking +Named parameter $a overwrites previous argument +array(1) { + ["b"]=> + int(1) +} +array(1) { + ["b"]=> + int(0) +} +a = a, b = b, c = c +a = a, b = b, c = c +a = a, b = b, c = c +Cannot use positional argument after named argument during unpacking +Named parameter $a overwrites previous argument + +Warning: Cannot pass by-reference argument 2 of test2() by unpacking a Traversable, passing by-value instead in %s on line %d +array(1) { + ["b"]=> + int(0) +} +array(1) { + ["b"]=> + int(0) +} diff --git a/Zend/tests/named_params/unpack_and_named_1.phpt b/Zend/tests/named_params/unpack_and_named_1.phpt new file mode 100644 index 0000000000..24d448dc8b --- /dev/null +++ b/Zend/tests/named_params/unpack_and_named_1.phpt @@ -0,0 +1,10 @@ +--TEST-- +Mixing unpacking and named params (1) +--FILE-- +<?php + +test(...[], a: 42); + +?> +--EXPECTF-- +Fatal error: Cannot combine named arguments and argument unpacking in %s on line %d diff --git a/Zend/tests/named_params/unpack_and_named_2.phpt b/Zend/tests/named_params/unpack_and_named_2.phpt new file mode 100644 index 0000000000..2035b2e2dd --- /dev/null +++ b/Zend/tests/named_params/unpack_and_named_2.phpt @@ -0,0 +1,10 @@ +--TEST-- +Mixing unpacking and named params (2) +--FILE-- +<?php + +test(a: 42, ...[]); + +?> +--EXPECTF-- +Fatal error: Cannot combine named arguments and argument unpacking in %s on line %d diff --git a/Zend/tests/named_params/variadic.phpt b/Zend/tests/named_params/variadic.phpt new file mode 100644 index 0000000000..212a4569fb --- /dev/null +++ b/Zend/tests/named_params/variadic.phpt @@ -0,0 +1,66 @@ +--TEST-- +Additional named params are collect into variadics +--FILE-- +<?php + +function test($a, string ...$extra) { + var_dump($a); + var_dump($extra); + // Extra named parameters do not contribute toward func_num_args() and func_get_args(). + var_dump(func_num_args()); + var_dump(func_get_args()); +} + +function test2(&...$refs) { + foreach ($refs as &$ref) $ref++; +} + +test(b: 'b', a: 'a', c: 'c', extra: 'extra'); +echo "\n"; + +test('a', 'b', 'c', d: 'd'); +echo "\n"; + +$x = 0; +$y = 0; +test2(x: $x, y: $y); +var_dump($x, $y); + +?> +--EXPECT-- +string(1) "a" +array(3) { + ["b"]=> + string(1) "b" + ["c"]=> + string(1) "c" + ["extra"]=> + string(5) "extra" +} +int(1) +array(1) { + [0]=> + string(1) "a" +} + +string(1) "a" +array(3) { + [0]=> + string(1) "b" + [1]=> + string(1) "c" + ["d"]=> + string(1) "d" +} +int(3) +array(3) { + [0]=> + string(1) "a" + [1]=> + string(1) "b" + [2]=> + string(1) "c" +} + +int(1) +int(1) diff --git a/Zend/zend_API.c b/Zend/zend_API.c index c6e4b03dfc..62387d1be5 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -234,6 +234,9 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_error(int error_code, case ZPP_ERROR_WRONG_STRING_OR_CLASS_OR_NULL: zend_wrong_parameter_string_or_class_or_null_error(num, name, arg); break; + case ZPP_ERROR_UNEXPECTED_EXTRA_NAMED: + zend_unexpected_extra_named_error(); + break; default: ZEND_ASSERT(error_code != ZPP_ERROR_OK); } @@ -306,6 +309,14 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(uint32_t num, ch } /* }}} */ +ZEND_API ZEND_COLD void ZEND_FASTCALL zend_unexpected_extra_named_error(void) +{ + const char *space; + const char *class_name = get_active_class_name(&space); + zend_argument_count_error("%s%s%s() does not accept unknown named parameters", + class_name, space, get_active_function_name()); +} + static ZEND_COLD void ZEND_FASTCALL zend_argument_error_variadic(zend_class_entry *error_ce, uint32_t arg_num, const char *format, va_list va) /* {{{ */ { const char *space; @@ -950,6 +961,11 @@ static int zend_parse_va_args(uint32_t num_args, const char *type_spec, va_list } /* mark the beginning of varargs */ post_varargs = max_num_args; + + if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_unexpected_extra_named_error(); + return FAILURE; + } break; default: @@ -2298,11 +2314,20 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio if (reg_function->common.arg_info && reg_function->common.num_args) { uint32_t i; for (i = 0; i < reg_function->common.num_args; i++) { - zend_arg_info *arg_info = ®_function->common.arg_info[i]; + zend_internal_arg_info *arg_info = ®_function->internal_function.arg_info[i]; ZEND_ASSERT(arg_info->name && "Parameter must have a name"); if (ZEND_TYPE_IS_SET(arg_info->type)) { reg_function->common.fn_flags |= ZEND_ACC_HAS_TYPE_HINTS; } +#if ZEND_DEBUG + for (uint32_t j = 0; j < i; j++) { + if (!strcmp(arg_info->name, reg_function->internal_function.arg_info[j].name)) { + zend_error_noreturn(E_CORE_ERROR, + "Duplicate parameter name $%s for function %s%s%s()", arg_info->name, + scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + } + } +#endif } } @@ -3305,6 +3330,7 @@ ZEND_API int zend_fcall_info_init(zval *callable, uint32_t check_flags, zend_fca fci->retval = NULL; fci->param_count = 0; fci->params = NULL; + fci->named_params = NULL; return SUCCESS; } diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 7733d18584..916a2ab425 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -47,6 +47,11 @@ typedef struct _zend_fcall_info { zval *params; zend_object *object; uint32_t param_count; + /* This hashtable can also contain positional arguments (with integer keys), + * which will be appended to the normal params[]. This makes it easier to + * integrate APIs like call_user_func_array(). The usual restriction that + * there may not be position arguments after named arguments applies. */ + HashTable *named_params; } zend_fcall_info; typedef struct _zend_fcall_info_cache { @@ -500,10 +505,13 @@ ZEND_API void add_property_zval_ex(zval *arg, const char *key, size_t key_len, z #define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value) -ZEND_API int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]); +ZEND_API int _call_user_function_impl(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], HashTable *named_params); -#define call_user_function(_unused, object, function_name, retval_ptr, param_count, params) \ - _call_user_function_ex(object, function_name, retval_ptr, param_count, params) +#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) \ + _call_user_function_impl(object, function_name, retval_ptr, param_count, params, NULL) + +#define call_user_function_named(function_table, object, function_name, retval_ptr, param_count, params, named_params) \ + _call_user_function_impl(object, function_name, retval_ptr, param_count, params, named_params) ZEND_API extern const zend_fcall_info empty_fcall_info; ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache; @@ -569,14 +577,14 @@ ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci * called_scope must be provided for instance and static method calls. */ ZEND_API void zend_call_known_function( zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr, - uint32_t param_count, zval *params); + uint32_t param_count, zval *params, HashTable *named_params); /* Call the provided zend_function instance method on an object. */ static zend_always_inline void zend_call_known_instance_method( zend_function *fn, zend_object *object, zval *retval_ptr, uint32_t param_count, zval *params) { - zend_call_known_function(fn, object, object->ce, retval_ptr, param_count, params); + zend_call_known_function(fn, object, object->ce, retval_ptr, param_count, params, NULL); } static zend_always_inline void zend_call_known_instance_method_with_0_params( @@ -1241,6 +1249,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_or_null_error(u ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_string_or_class_error(uint32_t num, const char *name, zval *arg); ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_string_or_class_or_null_error(uint32_t num, const char *name, zval *arg); ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(uint32_t num, char *error); +ZEND_API ZEND_COLD void ZEND_FASTCALL zend_unexpected_extra_named_error(void); ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error(zend_class_entry *error_ce, uint32_t arg_num, const char *format, ...); ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_type_error(uint32_t arg_num, const char *format, ...); ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_value_error(uint32_t arg_num, const char *format, ...); @@ -1254,6 +1263,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_value_error(uint32_t arg_num #define ZPP_ERROR_WRONG_COUNT 6 #define ZPP_ERROR_WRONG_STRING_OR_CLASS 7 #define ZPP_ERROR_WRONG_STRING_OR_CLASS_OR_NULL 8 +#define ZPP_ERROR_UNEXPECTED_EXTRA_NAMED 9 #define ZEND_PARSE_PARAMETERS_START_EX(flags, min_num_args, max_num_args) do { \ const int _flags = (flags); \ @@ -1701,11 +1711,31 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_value_error(uint32_t arg_num dest = NULL; \ dest_num = 0; \ } \ + if (UNEXPECTED(ZEND_CALL_INFO(execute_data) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { \ + _error_code = ZPP_ERROR_UNEXPECTED_EXTRA_NAMED; \ + break; \ + } \ } while (0); #define Z_PARAM_VARIADIC(spec, dest, dest_num) \ Z_PARAM_VARIADIC_EX(spec, dest, dest_num, 0) +#define Z_PARAM_VARIADIC_WITH_NAMED(dest, dest_num, dest_named) do { \ + int _num_varargs = _num_args - _i; \ + if (EXPECTED(_num_varargs > 0)) { \ + dest = _real_arg + 1; \ + dest_num = _num_varargs; \ + } else { \ + dest = NULL; \ + dest_num = 0; \ + } \ + if (ZEND_CALL_INFO(execute_data) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { \ + dest_named = execute_data->extra_named_params; \ + } else { \ + dest_named = NULL; \ + } \ + } while (0); + #define Z_PARAM_STR_OR_ARRAY_HT_EX(dest_str, dest_ht, allow_null) \ Z_PARAM_PROLOGUE(0, 0); \ if (UNEXPECTED(!zend_parse_arg_str_or_array_ht(_arg, &dest_str, &dest_ht, allow_null))) { \ diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 1affe08c37..e2a2aca698 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -2062,6 +2062,11 @@ simple_list: zend_ast_export_name(str, ast->child[1], 0, indent); } break; + case ZEND_AST_NAMED_ARG: + smart_str_append(str, zend_ast_get_str(ast->child[0])); + smart_str_appends(str, ": "); + ast = ast->child[1]; + goto tail_call; /* 3 child nodes */ case ZEND_AST_METHOD_CALL: diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 79af596f24..97236c5560 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -145,6 +145,7 @@ enum _zend_ast_kind { ZEND_AST_ATTRIBUTE, ZEND_AST_MATCH, ZEND_AST_MATCH_ARM, + ZEND_AST_NAMED_ARG, /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c index c58ff95fb6..e55f27f84a 100644 --- a/Zend/zend_attributes.c +++ b/Zend/zend_attributes.c @@ -29,6 +29,7 @@ static HashTable internal_attributes; void validate_attribute(zend_attribute *attr, uint32_t target, zend_class_entry *scope) { + // TODO: More proper signature validation: Too many args, incorrect arg names. if (attr->argc > 0) { zval flags; @@ -121,7 +122,7 @@ ZEND_API int zend_get_attribute_value(zval *ret, zend_attribute *attr, uint32_t return FAILURE; } - ZVAL_COPY_OR_DUP(ret, &attr->argv[i]); + ZVAL_COPY_OR_DUP(ret, &attr->args[i].value); if (Z_TYPE_P(ret) == IS_CONSTANT_AST) { if (SUCCESS != zval_update_constant_ex(ret, scope)) { @@ -182,7 +183,10 @@ static zend_always_inline void free_attribute(zend_attribute *attr, int persiste zend_string_release(attr->lcname); for (i = 0; i < attr->argc; i++) { - zval_ptr_dtor(&attr->argv[i]); + if (attr->args[i].name) { + zend_string_release(attr->args[i].name); + } + zval_ptr_dtor(&attr->args[i].value); } pefree(attr, persistent); @@ -219,7 +223,8 @@ ZEND_API zend_attribute *zend_add_attribute(HashTable **attributes, zend_bool pe /* Initialize arguments to avoid partial initialization in case of fatal errors. */ for (uint32_t i = 0; i < argc; i++) { - ZVAL_UNDEF(&attr->argv[i]); + attr->args[i].name = NULL; + ZVAL_UNDEF(&attr->args[i].value); } zend_hash_next_index_insert_ptr(*attributes, attr); diff --git a/Zend/zend_attributes.h b/Zend/zend_attributes.h index 16221fa542..6b7150a363 100644 --- a/Zend/zend_attributes.h +++ b/Zend/zend_attributes.h @@ -30,19 +30,25 @@ #define ZEND_ATTRIBUTE_IS_REPEATABLE (1<<6) #define ZEND_ATTRIBUTE_FLAGS ((1<<7) - 1) -#define ZEND_ATTRIBUTE_SIZE(argc) (sizeof(zend_attribute) + sizeof(zval) * (argc) - sizeof(zval)) +#define ZEND_ATTRIBUTE_SIZE(argc) \ + (sizeof(zend_attribute) + sizeof(zend_attribute_arg) * (argc) - sizeof(zend_attribute_arg)) BEGIN_EXTERN_C() extern ZEND_API zend_class_entry *zend_ce_attribute; +typedef struct { + zend_string *name; + zval value; +} zend_attribute_arg; + typedef struct _zend_attribute { zend_string *name; zend_string *lcname; /* Parameter offsets start at 1, everything else uses 0. */ uint32_t offset; uint32_t argc; - zval argv[1]; + zend_attribute_arg args[1]; } zend_attribute; typedef struct _zend_internal_attribute { diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 1de771660a..588c3c33d7 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -1640,18 +1640,34 @@ static void debug_backtrace_get_args(zend_execute_data *call, zval *arg_array) / } else { ZVAL_EMPTY_ARRAY(arg_array); } + + if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_string *name; + zval *arg; + SEPARATE_ARRAY(arg_array); + ZEND_HASH_FOREACH_STR_KEY_VAL(call->extra_named_params, name, arg) { + ZVAL_DEREF(arg); + Z_TRY_ADDREF_P(arg); + zend_hash_add_new(Z_ARRVAL_P(arg_array), name, arg); + } ZEND_HASH_FOREACH_END(); + } } /* }}} */ void debug_print_backtrace_args(zval *arg_array) /* {{{ */ { + zend_string *name; zval *tmp; int i = 0; - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arg_array), tmp) { + ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(arg_array), name, tmp) { if (i++) { ZEND_PUTS(", "); } + if (name) { + ZEND_PUTS(ZSTR_VAL(name)); + ZEND_PUTS(": "); + } zend_print_flat_zval_r(tmp); } ZEND_HASH_FOREACH_END(); } diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index e239547336..68ae1e47b0 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -48,9 +48,15 @@ static zend_object_handlers closure_handlers; ZEND_METHOD(Closure, __invoke) /* {{{ */ { zend_function *func = EX(func); - zval *arguments = ZEND_CALL_ARG(execute_data, 1); + zval *args; + uint32_t num_args; + HashTable *named_args; - if (call_user_function(CG(function_table), NULL, ZEND_THIS, return_value, ZEND_NUM_ARGS(), arguments) == FAILURE) { + ZEND_PARSE_PARAMETERS_START(0, -1) + Z_PARAM_VARIADIC_WITH_NAMED(args, num_args, named_args) + ZEND_PARSE_PARAMETERS_END(); + + if (call_user_function_named(CG(function_table), NULL, ZEND_THIS, return_value, num_args, args, named_args) == FAILURE) { RETVAL_FALSE; } @@ -122,9 +128,10 @@ ZEND_METHOD(Closure, call) fci.param_count = 0; fci.params = NULL; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "o*", &newthis, &fci.params, &fci.param_count) == FAILURE) { - RETURN_THROWS(); - } + ZEND_PARSE_PARAMETERS_START(1, -1) + Z_PARAM_OBJECT(newthis) + Z_PARAM_VARIADIC_WITH_NAMED(fci.params, fci.param_count, fci.named_params) + ZEND_PARSE_PARAMETERS_END(); closure = (zend_closure *) Z_OBJ_P(ZEND_THIS); @@ -246,6 +253,7 @@ static ZEND_NAMED_FUNCTION(zend_closure_call_magic) /* {{{ */ { fcc.function_handler = (EX(func)->internal_function.fn_flags & ZEND_ACC_STATIC) ? EX(func)->internal_function.scope->__callstatic : EX(func)->internal_function.scope->__call; + fci.named_params = NULL; fci.params = params; fci.param_count = 2; ZVAL_STR(&fci.params[0], EX(func)->common.function_name); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 790b2acc89..78b72de1a7 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3285,15 +3285,48 @@ void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ -uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ +static uint32_t zend_get_arg_num(zend_function *fn, zend_string *arg_name) { + // TODO: Caching? + if (fn->type == ZEND_USER_FUNCTION) { + for (uint32_t i = 0; i < fn->common.num_args; i++) { + zend_arg_info *arg_info = &fn->op_array.arg_info[i]; + if (zend_string_equals(arg_info->name, arg_name)) { + return i + 1; + } + } + } else { + for (uint32_t i = 0; i < fn->common.num_args; i++) { + zend_internal_arg_info *arg_info = &fn->internal_function.arg_info[i]; + size_t len = strlen(arg_info->name); + if (len == ZSTR_LEN(arg_name) && !memcmp(arg_info->name, ZSTR_VAL(arg_name), len)) { + return i + 1; + } + } + } + + /* Either an invalid argument name, or collected into a variadic argument. */ + return (uint32_t) -1; +} + +uint32_t zend_compile_args( + zend_ast *ast, zend_function *fbc, bool *may_have_extra_named_args) /* {{{ */ { zend_ast_list *args = zend_ast_get_list(ast); uint32_t i; zend_bool uses_arg_unpack = 0; uint32_t arg_count = 0; /* number of arguments not including unpacks */ + /* Whether named arguments are used syntactically, to enforce language level limitations. + * May not actually use named argument passing. */ + zend_bool uses_named_args = 0; + /* Whether there may be any undef arguments due to the use of named arguments. */ + zend_bool may_have_undef = 0; + /* Whether there may be any extra named arguments collected into a variadic. */ + *may_have_extra_named_args = 0; + for (i = 0; i < args->children; ++i) { zend_ast *arg = args->child[i]; + zend_string *arg_name = NULL; uint32_t arg_num = i + 1; znode arg_node; @@ -3301,6 +3334,11 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ zend_uchar opcode; if (arg->kind == ZEND_AST_UNPACK) { + if (uses_named_args) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot combine named arguments and argument unpacking"); + } + uses_arg_unpack = 1; fbc = NULL; @@ -3308,15 +3346,57 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL); opline->op2.num = arg_count; opline->result.var = EX_NUM_TO_VAR(arg_count - 1); + + /* Unpack may contain named arguments. */ + may_have_undef = 1; + if (!fbc || (fbc->common.fn_flags & ZEND_ACC_VARIADIC)) { + *may_have_extra_named_args = 1; + } continue; } - if (uses_arg_unpack) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use positional argument after argument unpacking"); + if (arg->kind == ZEND_AST_NAMED_ARG) { + if (uses_arg_unpack) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot combine named arguments and argument unpacking"); + } + + uses_named_args = 1; + arg_name = zval_make_interned_string(zend_ast_get_zval(arg->child[0])); + arg = arg->child[1]; + + if (fbc) { + arg_num = zend_get_arg_num(fbc, arg_name); + if (arg_num == arg_count + 1) { + /* Using named arguments, but passing in order. */ + arg_name = NULL; + arg_count++; + } else { + // TODO: We could track which arguments were passed, even if out of order. + may_have_undef = 1; + if (arg_num == (uint32_t) -1 && (fbc->common.fn_flags & ZEND_ACC_VARIADIC)) { + *may_have_extra_named_args = 1; + } + } + } else { + arg_num = (uint32_t) -1; + may_have_undef = 1; + *may_have_extra_named_args = 1; + } + } else { + if (uses_arg_unpack) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after argument unpacking"); + } + + if (uses_named_args) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after named argument"); + } + + arg_count++; } - arg_count++; if (zend_is_call(arg)) { zend_compile_var(&arg_node, arg, BP_VAR_R, 0); if (arg_node.op_type & (IS_CONST|IS_TMP_VAR)) { @@ -3327,7 +3407,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ opcode = ZEND_SEND_VAL; } } else { - if (fbc) { + if (fbc && arg_num != (uint32_t) -1) { if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { opcode = ZEND_SEND_VAR_NO_REF; } else if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) { @@ -3340,7 +3420,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ } } } else if (zend_is_variable(arg) && !zend_ast_is_short_circuited(arg)) { - if (fbc) { + if (fbc && arg_num != (uint32_t) -1) { if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { zend_compile_var(&arg_node, arg, BP_VAR_W, 1); opcode = ZEND_SEND_REF; @@ -3363,7 +3443,14 @@ 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; + if (arg_name) { + opline->op2_type = IS_CONST; + zend_string_addref(arg_name); + opline->op2.constant = zend_add_literal_string(&arg_name); + opline->result.num = zend_alloc_cache_slots(2); + } else { + opline->op2.num = arg_num; + } zend_compile_var(&arg_node, arg, BP_VAR_FUNC_ARG, 1); opcode = ZEND_SEND_FUNC_ARG; } while (0); @@ -3372,7 +3459,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ zend_compile_expr(&arg_node, arg); if (arg_node.op_type == IS_VAR) { /* pass ++$a or something similar */ - if (fbc) { + if (fbc && arg_num != (uint32_t) -1) { if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { opcode = ZEND_SEND_VAR_NO_REF; } else if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) { @@ -3384,7 +3471,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ opcode = ZEND_SEND_VAR_NO_REF_EX; } } else if (arg_node.op_type == IS_CV) { - if (fbc) { + if (fbc && arg_num != (uint32_t) -1) { if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { opcode = ZEND_SEND_REF; } else { @@ -3395,7 +3482,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ } } else { /* Delay "Only variables can be passed by reference" error to execution */ - if (fbc && !ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + if (fbc && arg_num != (uint32_t) -1 && !ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { opcode = ZEND_SEND_VAL; } else { opcode = ZEND_SEND_VAL_EX; @@ -3404,8 +3491,19 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ } opline = zend_emit_op(NULL, opcode, &arg_node, NULL); - opline->op2.opline_num = arg_num; - opline->result.var = EX_NUM_TO_VAR(arg_num - 1); + if (arg_name) { + opline->op2_type = IS_CONST; + zend_string_addref(arg_name); + opline->op2.constant = zend_add_literal_string(&arg_name); + opline->result.num = zend_alloc_cache_slots(2); + } else { + opline->op2.opline_num = arg_num; + opline->result.var = EX_NUM_TO_VAR(arg_num - 1); + } + } + + if (may_have_undef) { + zend_emit_op(NULL, ZEND_CHECK_UNDEF_ARGS, NULL, NULL); } return arg_count; @@ -3443,8 +3541,9 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function * zend_op *opline; uint32_t opnum_init = get_next_op_number() - 1; uint32_t arg_count; + bool may_have_extra_named_args; - arg_count = zend_compile_args(args_ast, fbc); + arg_count = zend_compile_args(args_ast, fbc, &may_have_extra_named_args); zend_do_extended_fcall_begin(); @@ -3456,6 +3555,9 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function * } opline = zend_emit_op(result, zend_get_call_op(opline, fbc), NULL, NULL); + if (may_have_extra_named_args) { + opline->extended_value = ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS; + } zend_do_extended_fcall_end(); } /* }}} */ @@ -3520,11 +3622,12 @@ void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_a } /* }}} */ -static inline zend_bool zend_args_contain_unpack(zend_ast_list *args) /* {{{ */ +static inline zend_bool zend_args_contain_unpack_or_named(zend_ast_list *args) /* {{{ */ { uint32_t i; for (i = 0; i < args->children; ++i) { - if (args->child[i]->kind == ZEND_AST_UNPACK) { + zend_ast *arg = args->child[i]; + if (arg->kind == ZEND_AST_UNPACK || arg->kind == ZEND_AST_NAMED_ARG) { return 1; } } @@ -3774,6 +3877,7 @@ int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcna } zend_compile_expr(&arg_node, args->child[1]); zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL); + zend_emit_op(NULL, ZEND_CHECK_UNDEF_ARGS, NULL, NULL); zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL); return SUCCESS; @@ -4080,7 +4184,7 @@ int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_l return FAILURE; } - if (zend_args_contain_unpack(args)) { + if (zend_args_contain_unpack_or_named(args)) { return FAILURE; } @@ -6111,13 +6215,33 @@ static void zend_compile_attributes(HashTable **attributes, zend_ast *ast, uint3 if (args) { ZEND_ASSERT(args->kind == ZEND_AST_ARG_LIST); + zend_bool uses_named_args = 0; for (j = 0; j < args->children; j++) { - if (args->child[j]->kind == ZEND_AST_UNPACK) { + zend_ast *arg_ast = args->child[j]; + + if (arg_ast->kind == ZEND_AST_UNPACK) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use unpacking in attribute argument list"); } - zend_const_expr_to_zval(&attr->argv[j], args->child[j]); + if (arg_ast->kind == ZEND_AST_NAMED_ARG) { + attr->args[j].name = zend_string_copy(zend_ast_get_str(arg_ast->child[0])); + arg_ast = arg_ast->child[1]; + uses_named_args = 1; + + for (uint32_t k = 0; k < j; k++) { + if (attr->args[k].name && + zend_string_equals(attr->args[k].name, attr->args[j].name)) { + zend_error_noreturn(E_COMPILE_ERROR, "Duplicate named parameter $%s", + ZSTR_VAL(attr->args[j].name)); + } + } + } else if (uses_named_args) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use positional argument after named argument"); + } + + zend_const_expr_to_zval(&attr->args[j].value, arg_ast); } } } diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index d804b998de..df3171f76d 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -511,6 +511,7 @@ struct _zend_execute_data { zend_execute_data *prev_execute_data; zend_array *symbol_table; void **run_time_cache; /* cache op_array->run_time_cache */ + zend_array *extra_named_params; }; #define ZEND_CALL_HAS_THIS IS_OBJECT_EX @@ -528,6 +529,8 @@ struct _zend_execute_data { #define ZEND_CALL_FAKE_CLOSURE (1 << 23) #define ZEND_CALL_GENERATOR (1 << 24) #define ZEND_CALL_DYNAMIC (1 << 25) +#define ZEND_CALL_MAY_HAVE_UNDEF (1 << 26) +#define ZEND_CALL_HAS_EXTRA_NAMED_PARAMS (1 << 27) #define ZEND_CALL_SEND_ARG_BY_REF (1u << 31) #define ZEND_CALL_NESTED_FUNCTION (ZEND_CALL_FUNCTION | ZEND_CALL_NESTED) @@ -951,6 +954,8 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_THROW_IS_EXPR 1u +#define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS 1 + /* The send mode and is_variadic flag are stored as part of zend_type */ #define _ZEND_SEND_MODE_SHIFT _ZEND_TYPE_EXTRA_FLAGS_SHIFT #define _ZEND_IS_VARIADIC_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 2)) diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 8c96bb6098..85ca5f74b3 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -566,9 +566,14 @@ static void _build_trace_string(smart_str *str, HashTable *ht, uint32_t num) /* if (tmp) { if (Z_TYPE_P(tmp) == IS_ARRAY) { size_t last_len = ZSTR_LEN(str->s); + zend_string *name; zval *arg; - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmp), arg) { + ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(tmp), name, arg) { + if (name) { + smart_str_append(str, name); + smart_str_appends(str, ": "); + } _build_trace_args(arg, str); } ZEND_HASH_FOREACH_END(); @@ -662,6 +667,7 @@ ZEND_METHOD(Exception, __toString) fci.retval = &trace; fci.param_count = 0; fci.params = NULL; + fci.named_params = NULL; zend_call_function(&fci, NULL); diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index d6809cb670..b89809c88a 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3671,7 +3671,7 @@ ZEND_API void zend_init_execute_data(zend_execute_data *execute_data, zend_op_ar } /* }}} */ -static zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call, uint32_t passed_args, uint32_t additional_args) /* {{{ */ +zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call, uint32_t passed_args, uint32_t additional_args) /* {{{ */ { zend_execute_data *new_call; int used_stack = (EG(vm_stack_top) - (zval*)call) + additional_args; @@ -3707,16 +3707,6 @@ static zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call, } /* }}} */ -static zend_always_inline void zend_vm_stack_extend_call_frame(zend_execute_data **call, uint32_t passed_args, uint32_t additional_args) /* {{{ */ -{ - if (EXPECTED((uint32_t)(EG(vm_stack_end) - EG(vm_stack_top)) > additional_args)) { - EG(vm_stack_top) += additional_args; - } else { - *call = zend_vm_stack_copy_call_frame(*call, passed_args, additional_args); - } -} -/* }}} */ - static zend_always_inline zend_generator *zend_get_running_generator(EXECUTE_DATA_D) /* {{{ */ { /* The generator object is stored in EX(return_value) */ @@ -3786,12 +3776,16 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_USER: if (level == 0) { - ZEND_CALL_NUM_ARGS(call) = opline->op2.num; + /* For named args, the number of arguments is up to date. */ + if (opline->op2_type != IS_CONST) { + ZEND_CALL_NUM_ARGS(call) = opline->op2.num; + } do_exit = 1; } break; case ZEND_SEND_ARRAY: case ZEND_SEND_UNPACK: + case ZEND_CHECK_UNDEF_ARGS: if (level == 0) { do_exit = 1; } @@ -3836,6 +3830,9 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) { OBJ_RELEASE(Z_OBJ(call->This)); } + if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } if (call->func->common.fn_flags & ZEND_ACC_CLOSURE) { zend_object_release(ZEND_CLOSURE_OBJECT(call->func)); } else if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) { @@ -4336,6 +4333,226 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant( return _zend_quick_get_constant(key, 0, 1 OPLINE_CC EXECUTE_DATA_CC); } /* }}} */ +static zend_always_inline uint32_t zend_get_arg_offset_by_name( + zend_function *fbc, zend_string *arg_name, void **cache_slot) { + if (EXPECTED(*cache_slot == fbc)) { + return *(uintptr_t *)(cache_slot + 1); + } + + // TODO: Use a hash table? + uint32_t num_args = fbc->common.num_args; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) + || EXPECTED(fbc->common.fn_flags & ZEND_ACC_USER_ARG_INFO)) { + for (uint32_t i = 0; i < num_args; i++) { + zend_arg_info *arg_info = &fbc->op_array.arg_info[i]; + if (zend_string_equals(arg_name, arg_info->name)) { + *cache_slot = fbc; + *(uintptr_t *)(cache_slot + 1) = i; + return i; + } + } + } else { + for (uint32_t i = 0; i < num_args; i++) { + zend_internal_arg_info *arg_info = &fbc->internal_function.arg_info[i]; + size_t len = strlen(arg_info->name); + if (len == ZSTR_LEN(arg_name) && !memcmp(arg_info->name, ZSTR_VAL(arg_name), len)) { + *cache_slot = fbc; + *(uintptr_t *)(cache_slot + 1) = i; + return i; + } + } + } + + if (fbc->common.fn_flags & ZEND_ACC_VARIADIC) { + *cache_slot = fbc; + *(uintptr_t *)(cache_slot + 1) = fbc->common.num_args; + return fbc->common.num_args; + } + + return (uint32_t) -1; +} + +zval * ZEND_FASTCALL zend_handle_named_arg( + zend_execute_data **call_ptr, zend_string *arg_name, + uint32_t *arg_num_ptr, void **cache_slot) { + zend_execute_data *call = *call_ptr; + zend_function *fbc = call->func; + uint32_t arg_offset = zend_get_arg_offset_by_name(fbc, arg_name, cache_slot); + if (UNEXPECTED(arg_offset == (uint32_t) -1)) { + zend_throw_error(NULL, "Unknown named parameter $%s", ZSTR_VAL(arg_name)); + return NULL; + } + + zval *arg; + if (UNEXPECTED(arg_offset == fbc->common.num_args)) { + /* Unknown named parameter that will be collected into a variadic. */ + if (!(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_HAS_EXTRA_NAMED_PARAMS); + call->extra_named_params = zend_new_array(0); + } + + arg = zend_hash_add_empty_element(call->extra_named_params, arg_name); + if (!arg) { + zend_throw_error(NULL, "Named parameter $%s overwrites previous argument", + ZSTR_VAL(arg_name)); + return NULL; + } + *arg_num_ptr = arg_offset + 1; + return arg; + } + + uint32_t current_num_args = ZEND_CALL_NUM_ARGS(call); + // TODO: We may wish to optimize the arg_offset == current_num_args case, + // which is probably common (if the named parameters are in order of declaration). + if (arg_offset >= current_num_args) { + uint32_t new_num_args = arg_offset + 1; + ZEND_CALL_NUM_ARGS(call) = new_num_args; + + uint32_t num_extra_args = new_num_args - current_num_args; + zend_vm_stack_extend_call_frame(call_ptr, current_num_args, num_extra_args); + call = *call_ptr; + + arg = ZEND_CALL_VAR_NUM(call, arg_offset); + if (num_extra_args > 1) { + zval *zv = ZEND_CALL_VAR_NUM(call, current_num_args); + do { + ZVAL_UNDEF(zv); + zv++; + } while (zv != arg); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_MAY_HAVE_UNDEF); + } + } else { + arg = ZEND_CALL_VAR_NUM(call, arg_offset); + if (UNEXPECTED(!Z_ISUNDEF_P(arg))) { + zend_throw_error(NULL, "Named parameter $%s overwrites previous argument", + ZSTR_VAL(arg_name)); + return NULL; + } + } + + *arg_num_ptr = arg_offset + 1; + return arg; +} + +static void start_fake_frame(zend_execute_data *call, const zend_op *opline) { + zend_execute_data *prev_execute_data = EG(current_execute_data); + call->prev_execute_data = prev_execute_data; + call->opline = opline; + EG(current_execute_data) = call; +} + +static void end_fake_frame(zend_execute_data *call) { + zend_execute_data *prev_execute_data = call->prev_execute_data; + EG(current_execute_data) = prev_execute_data; + call->prev_execute_data = NULL; + if (UNEXPECTED(EG(exception)) && ZEND_USER_CODE(prev_execute_data->func->common.type)) { + zend_rethrow_exception(prev_execute_data); + } +} + +ZEND_API int ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *call) { + zend_function *fbc = call->func; + if (fbc->type == ZEND_USER_FUNCTION) { + uint32_t num_args = ZEND_CALL_NUM_ARGS(call); + for (uint32_t i = 0; i < num_args; i++) { + zval *arg = ZEND_CALL_VAR_NUM(call, i); + if (!Z_ISUNDEF_P(arg)) { + continue; + } + + zend_op_array *op_array = &fbc->op_array; + zend_op *opline = &op_array->opcodes[i]; + if (EXPECTED(opline->opcode == ZEND_RECV_INIT)) { + zval *default_value = RT_CONSTANT(opline, opline->op2); + if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) { + void *run_time_cache = RUN_TIME_CACHE(op_array); + zval *cache_val = + (zval *) ((char *) run_time_cache + Z_CACHE_SLOT_P(default_value)); + + if (Z_TYPE_P(cache_val) != IS_UNDEF) { + /* We keep in cache only not refcounted values */ + ZVAL_COPY_VALUE(arg, cache_val); + } else { + /* Update constant inside a temporary zval, to make sure the CONSTANT_AST + * value is not accessible through back traces. */ + zval tmp; + ZVAL_COPY(&tmp, default_value); + start_fake_frame(call, opline); + int ret = zval_update_constant_ex(&tmp, fbc->op_array.scope); + end_fake_frame(call); + if (UNEXPECTED(ret == FAILURE)) { + zval_ptr_dtor_nogc(&tmp); + return FAILURE; + } + ZVAL_COPY_VALUE(arg, &tmp); + if (!Z_REFCOUNTED(tmp)) { + ZVAL_COPY_VALUE(cache_val, &tmp); + } + } + } else { + ZVAL_COPY(arg, default_value); + } + } else { + ZEND_ASSERT(opline->opcode == ZEND_RECV); + start_fake_frame(call, opline); + zend_argument_error(zend_ce_argument_count_error, i + 1, "not passed"); + end_fake_frame(call); + } + } + + return SUCCESS; + } else { + if (fbc->common.fn_flags & ZEND_ACC_USER_ARG_INFO) { + /* Magic function, let it deal with it. */ + return SUCCESS; + } + + uint32_t num_args = ZEND_CALL_NUM_ARGS(call); + for (uint32_t i = 0; i < num_args; i++) { + zval *arg = ZEND_CALL_VAR_NUM(call, i); + if (!Z_ISUNDEF_P(arg)) { + continue; + } + + zend_internal_arg_info *arg_info = &fbc->internal_function.arg_info[i]; + if (i < fbc->common.required_num_args) { + start_fake_frame(call, NULL); + zend_argument_error(zend_ce_argument_count_error, i + 1, "not passed"); + end_fake_frame(call); + return FAILURE; + } + + zval default_value; + if (zend_get_default_from_internal_arg_info(&default_value, arg_info) == FAILURE) { + start_fake_frame(call, NULL); + zend_argument_error(zend_ce_argument_count_error, i + 1, + "must be passed explicitly, because the default value is not known"); + end_fake_frame(call); + return FAILURE; + } + + if (Z_TYPE(default_value) == IS_CONSTANT_AST) { + start_fake_frame(call, NULL); + int ret = zval_update_constant_ex(&default_value, fbc->common.scope); + end_fake_frame(call); + if (ret == FAILURE) { + return FAILURE; + } + } + + ZVAL_COPY_VALUE(arg, &default_value); + } + } + + return SUCCESS; +} + +ZEND_API void ZEND_FASTCALL zend_free_extra_named_params(zend_array *extra_named_params) +{ + /* Extra named params may be shared. */ + zend_array_release(extra_named_params); +} + #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) /* Special versions of functions that sets EX(opline) before calling zend_vm_stack_extend() */ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame_ex(uint32_t used_stack, uint32_t call_info, zend_function *func, uint32_t num_args, void *object_or_called_scope) /* {{{ */ diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index 827b735c70..f93a9f5e0e 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -291,6 +291,21 @@ static zend_always_inline void zend_vm_stack_free_call_frame(zend_execute_data * zend_vm_stack_free_call_frame_ex(ZEND_CALL_INFO(call), call); } +zend_execute_data *zend_vm_stack_copy_call_frame( + zend_execute_data *call, uint32_t passed_args, uint32_t additional_args); + +static zend_always_inline void zend_vm_stack_extend_call_frame( + zend_execute_data **call, uint32_t passed_args, uint32_t additional_args) +{ + if (EXPECTED((uint32_t)(EG(vm_stack_end) - EG(vm_stack_top)) > additional_args)) { + EG(vm_stack_top) += additional_args; + } else { + *call = zend_vm_stack_copy_call_frame(*call, passed_args, additional_args); + } +} + +ZEND_API void ZEND_FASTCALL zend_free_extra_named_params(zend_array *extra_named_params); + /* services */ ZEND_API const char *get_active_class_name(const char **space); ZEND_API const char *get_active_function_name(void); @@ -333,6 +348,11 @@ ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table); ZEND_API void zend_free_compiled_variables(zend_execute_data *execute_data); ZEND_API void zend_cleanup_unfinished_execution(zend_execute_data *execute_data, uint32_t op_num, uint32_t catch_op_num); +zval * ZEND_FASTCALL zend_handle_named_arg( + zend_execute_data **call_ptr, zend_string *arg_name, + uint32_t *arg_num_ptr, void **cache_slot); +ZEND_API int ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *call); + #define CACHE_ADDR(num) \ ((void**)((char*)EX(run_time_cache) + (num))) diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index e6f1e44fca..b3d6319560 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -619,7 +619,7 @@ ZEND_API int zval_update_constant(zval *pp) /* {{{ */ } /* }}} */ -int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]) /* {{{ */ +int _call_user_function_impl(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], HashTable *named_params) /* {{{ */ { zend_fcall_info fci; @@ -629,6 +629,7 @@ int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, fci.retval = retval_ptr; fci.param_count = param_count; fci.params = params; + fci.named_params = named_params; return zend_call_function(&fci, NULL); } @@ -731,8 +732,14 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } for (i=0; i<fci->param_count; i++) { - zval *param; + zval *param = ZEND_CALL_ARG(call, i+1); zval *arg = &fci->params[i]; + if (UNEXPECTED(Z_ISUNDEF_P(arg))) { + /* Allow forwarding undef slots. This is only used by Closure::__invoke(). */ + ZVAL_UNDEF(param); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_MAY_HAVE_UNDEF); + continue; + } if (ARG_SHOULD_BE_SENT_BY_REF(func, i + 1)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { @@ -742,6 +749,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / zend_param_must_be_ref(func, i + 1); if (UNEXPECTED(EG(exception))) { ZEND_CALL_NUM_ARGS(call) = i; +cleanup_args: zend_vm_stack_free_args(call); zend_vm_stack_free_call_frame(call); if (EG(current_execute_data) == &dummy_execute_data) { @@ -759,10 +767,61 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } } - param = ZEND_CALL_ARG(call, i+1); ZVAL_COPY(param, arg); } + if (fci->named_params) { + zend_string *name; + zval *arg; + uint32_t arg_num = ZEND_CALL_NUM_ARGS(call) + 1; + zend_bool have_named_params = 0; + ZEND_HASH_FOREACH_STR_KEY_VAL(fci->named_params, name, arg) { + zval *target; + if (name) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + target = zend_handle_named_arg(&call, name, &arg_num, cache_slot); + if (!target) { + goto cleanup_args; + } + } else { + if (have_named_params) { + zend_throw_error(NULL, + "Cannot use positional argument after named argument"); + goto cleanup_args; + } + + zend_vm_stack_extend_call_frame(&call, arg_num - 1, 1); + target = ZEND_CALL_ARG(call, arg_num); + } + + if (ARG_SHOULD_BE_SENT_BY_REF(func, arg_num)) { + if (UNEXPECTED(!Z_ISREF_P(arg))) { + if (!ARG_MAY_BE_SENT_BY_REF(func, arg_num)) { + /* By-value send is not allowed -- emit a warning, + * but still perform the call with a by-value send. */ + zend_param_must_be_ref(func, arg_num); + if (UNEXPECTED(EG(exception))) { + goto cleanup_args; + } + } + } + } else { + if (Z_ISREF_P(arg) && + !(func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { + /* don't separate references for __call */ + arg = Z_REFVAL_P(arg); + } + } + + ZVAL_COPY(target, arg); + if (!name) { + ZEND_CALL_NUM_ARGS(call)++; + arg_num++; + } + } ZEND_HASH_FOREACH_END(); + } + if (UNEXPECTED(func->op_array.fn_flags & ZEND_ACC_CLOSURE)) { uint32_t call_info; @@ -774,6 +833,17 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / ZEND_ADD_CALL_FLAG(call, call_info); } + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF)) { + if (zend_handle_undef_args(call) == FAILURE) { + zend_vm_stack_free_args(call); + zend_vm_stack_free_call_frame(call); + if (EG(current_execute_data) == &dummy_execute_data) { + EG(current_execute_data) = dummy_execute_data.prev_execute_data; + } + return SUCCESS; + } + } + orig_fake_scope = EG(fake_scope); EG(fake_scope) = NULL; if (func->type == ZEND_USER_FUNCTION) { @@ -804,6 +874,9 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / } EG(current_execute_data) = call->prev_execute_data; zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_array_release(call->extra_named_params); + } if (EG(exception)) { zval_ptr_dtor(fci->retval); @@ -849,7 +922,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / ZEND_API void zend_call_known_function( zend_function *fn, zend_object *object, zend_class_entry *called_scope, zval *retval_ptr, - uint32_t param_count, zval *params) + uint32_t param_count, zval *params, HashTable *named_params) { zval retval; zend_fcall_info fci; @@ -862,6 +935,7 @@ ZEND_API void zend_call_known_function( fci.retval = retval_ptr ? retval_ptr : &retval; fci.param_count = param_count; fci.params = params; + fci.named_params = named_params; ZVAL_UNDEF(&fci.function_name); /* Unused */ fcic.function_handler = fn; diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 21a44b3865..0d2d7e4a4d 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -127,6 +127,9 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished } /* always free the CV's, in the symtable are only not-free'd IS_INDIRECT's */ zend_free_compiled_variables(execute_data); + if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(execute_data->extra_named_params); + } if (EX_CALL_INFO() & ZEND_CALL_RELEASE_THIS) { OBJ_RELEASE(Z_OBJ(execute_data->This)); @@ -312,6 +315,11 @@ static HashTable *zend_generator_get_gc(zend_object *object, zval **table, int * if (EX_CALL_INFO() & ZEND_CALL_CLOSURE) { zend_get_gc_buffer_add_obj(gc_buffer, ZEND_CLOSURE_OBJECT(EX(func))); } + if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zval extra_named_params; + ZVAL_ARR(&extra_named_params, EX(extra_named_params)); + zend_get_gc_buffer_add_zval(gc_buffer, &extra_named_params); + } if (execute_data->opline != op_array->opcodes) { uint32_t i, op_num = execute_data->opline - op_array->opcodes - 1; diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c index 37c72ef554..16c193e420 100644 --- a/Zend/zend_interfaces.c +++ b/Zend/zend_interfaces.c @@ -79,7 +79,7 @@ ZEND_API zval* zend_call_method(zend_object *object, zend_class_entry *obj_ce, z called_scope = obj_ce; } - zend_call_known_function(fn, object, called_scope, retval_ptr, param_count, params); + zend_call_known_function(fn, object, called_scope, retval_ptr, param_count, params, NULL); return retval_ptr; } /* }}} */ diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 55f2c0f49c..1a566e352d 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -806,7 +806,9 @@ non_empty_argument_list: ; argument: - expr { $$ = $1; } + expr { $$ = $1; } + | identifier ':' expr + { $$ = zend_ast_create(ZEND_AST_NAMED_ARG, $1, $3); } | T_ELLIPSIS expr { $$ = zend_ast_create(ZEND_AST_UNPACK, $2); } ; diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index ebec6921cb..b3eb2d1ba5 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -1110,6 +1110,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend * The low bit must be zero, to not be interpreted as a MAP_PTR offset. */ static const void *dummy = (void*)(intptr_t)2; + static const zend_arg_info arg_info[1] = {{0}}; ZEND_ASSERT(fbc); @@ -1123,7 +1124,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend func->arg_flags[0] = 0; func->arg_flags[1] = 0; func->arg_flags[2] = 0; - func->fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_PUBLIC; + func->fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_PUBLIC | ZEND_ACC_VARIADIC; if (is_static) { func->fn_flags |= ZEND_ACC_STATIC; } @@ -1147,7 +1148,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend func->prototype = NULL; func->num_args = 0; func->required_num_args = 0; - func->arg_info = 0; + func->arg_info = (zend_arg_info *) arg_info; return (zend_function*)func; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index a9b5c0f4a3..86a86bd652 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2761,7 +2761,7 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -2794,6 +2794,10 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) zend_clean_and_cache_symbol_table(EX(symbol_table)); } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } + /* Free extra args before releasing the closure, * as that may free the op_array. */ zend_vm_stack_free_extra_args_ex(call_info, execute_data); @@ -2841,11 +2845,14 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) #ifdef ZEND_PREFER_RELOAD call_info = EX_CALL_INFO(); #endif - if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) { + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) { if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_clean_and_cache_symbol_table(EX(symbol_table)); } zend_vm_stack_free_extra_args_ex(call_info, execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } } if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); @@ -3896,7 +3903,16 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL)) EG(current_execute_data) = execute_data; zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); @@ -4000,7 +4016,16 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) ZEND_VM_C_LABEL(fcall_by_name_end): zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); @@ -4094,6 +4119,10 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) ZEND_VM_C_LABEL(fcall_end): zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(call->extra_named_params); + } + if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); } @@ -4517,13 +4546,24 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_HANDLER(65, ZEND_SEND_VAL, CONST|TMPVAR, NUM) +ZEND_VM_HOT_HANDLER(65, ZEND_SEND_VAL, CONST|TMPVAR, CONST|UNUSED|NUM) { USE_OPLINE zval *value, *arg; + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + value = GET_OP1_ZVAL_PTR(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, value); if (OP1_TYPE == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { @@ -4547,11 +4587,23 @@ ZEND_VM_COLD_HELPER(zend_cannot_pass_by_ref_helper, ANY, ANY) HANDLE_EXCEPTION(); } -ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, NUM, SPEC(QUICK_ARG)) +ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, CONST|UNUSED|NUM, SPEC(QUICK_ARG)) { USE_OPLINE zval *value, *arg; - uint32_t arg_num = opline->op2.num; + uint32_t arg_num; + + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { @@ -4562,7 +4614,6 @@ ZEND_VM_C_LABEL(send_val_by_ref): ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper); } value = GET_OP1_ZVAL_PTR(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, value); if (OP1_TYPE == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { @@ -4572,22 +4623,31 @@ ZEND_VM_C_LABEL(send_val_by_ref): ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(117, ZEND_SEND_VAR, VAR|CV, NUM) +ZEND_VM_HOT_HANDLER(117, ZEND_SEND_VAR, VAR|CV, CONST|UNUSED|NUM) { USE_OPLINE zval *varptr, *arg; + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_NULL(arg); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - if (OP1_TYPE == IS_CV) { ZVAL_COPY_DEREF(arg, varptr); } else /* if (OP1_TYPE == IS_VAR) */ { @@ -4609,13 +4669,24 @@ ZEND_VM_HOT_HANDLER(117, ZEND_SEND_VAR, VAR|CV, NUM) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM) +ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, CONST|UNUSED|NUM) { USE_OPLINE zval *varptr, *arg; + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + varptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, varptr); if (EXPECTED(Z_ISREF_P(varptr))) { @@ -4628,19 +4699,30 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_SEND_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, NUM, SPEC(QUICK_ARG)) +ZEND_VM_HOT_SEND_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, CONST|UNUSED|NUM, SPEC(QUICK_ARG)) { USE_OPLINE zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; + uint32_t arg_num; + + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR); + ZEND_VM_C_GOTO(send_var); } varptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, varptr); if (EXPECTED(Z_ISREF_P(varptr) || @@ -4649,11 +4731,10 @@ ZEND_VM_HOT_SEND_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, NUM, SPEC(QUICK_ARG)) } } else { if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR); + ZEND_VM_C_GOTO(send_var); } varptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); ZVAL_COPY_VALUE(arg, varptr); if (EXPECTED(Z_ISREF_P(varptr) || @@ -4666,17 +4747,43 @@ ZEND_VM_HOT_SEND_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, NUM, SPEC(QUICK_ARG)) ZVAL_NEW_REF(arg, arg); zend_error(E_NOTICE, "Only variables should be passed by reference"); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + +ZEND_VM_C_LABEL(send_var): + varptr = GET_OP1_ZVAL_PTR(BP_VAR_R); + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM) +ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, CONST|UNUSED|NUM) { USE_OPLINE zval *varptr, *arg; SAVE_OPLINE(); - varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); + if (OP2_TYPE == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } - arg = ZEND_CALL_VAR(EX(call), opline->result.var); + varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); if (Z_ISREF_P(varptr)) { Z_ADDREF_P(varptr); } else { @@ -4688,11 +4795,23 @@ ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_SEND_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, NUM, SPEC(QUICK_ARG)) +ZEND_VM_HOT_SEND_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, CONST|UNUSED|NUM, SPEC(QUICK_ARG)) { USE_OPLINE zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; + uint32_t arg_num; + + if (OP2_TYPE == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { @@ -4700,7 +4819,16 @@ ZEND_VM_HOT_SEND_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, NUM, SPEC(QUICK_ARG)) } } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { ZEND_VM_C_LABEL(send_var_by_ref): - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF); + varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + FREE_OP1_VAR_PTR(); + ZEND_VM_NEXT_OPCODE(); } varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); @@ -4712,8 +4840,6 @@ ZEND_VM_C_LABEL(send_var_by_ref): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - if (OP1_TYPE == IS_CV) { ZVAL_COPY_DEREF(arg, varptr); } else /* if (OP1_TYPE == IS_VAR) */ { @@ -4735,10 +4861,23 @@ ZEND_VM_C_LABEL(send_var_by_ref): ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_SEND_HANDLER(100, ZEND_CHECK_FUNC_ARG, UNUSED, NUM, SPEC(QUICK_ARG)) +ZEND_VM_HOT_SEND_HANDLER(100, ZEND_CHECK_FUNC_ARG, UNUSED, CONST|UNUSED|NUM, SPEC(QUICK_ARG)) { USE_OPLINE - uint32_t arg_num = opline->op2.num; + uint32_t arg_num; + + if (OP2_TYPE == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg_num = zend_get_arg_offset_by_name( + EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1; + if (UNEXPECTED(arg_num == 0)) { + /* Treat this as a by-value argument, and throw an error during SEND. */ + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + ZEND_VM_NEXT_OPCODE(); + } + } else { + arg_num = opline->op2.num; + } if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { @@ -4754,17 +4893,38 @@ ZEND_VM_HOT_SEND_HANDLER(100, ZEND_CHECK_FUNC_ARG, UNUSED, NUM, SPEC(QUICK_ARG)) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(185, ZEND_SEND_FUNC_ARG, VAR, NUM) +ZEND_VM_HOT_HANDLER(185, ZEND_SEND_FUNC_ARG, VAR, CONST|UNUSED|NUM) { USE_OPLINE zval *varptr, *arg; + if (OP2_TYPE == IS_CONST) { + // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF); + varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + FREE_OP1_VAR_PTR(); + ZEND_VM_NEXT_OPCODE(); } varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(Z_ISREF_P(varptr))) { zend_refcounted *ref = Z_COUNTED_P(varptr); @@ -4787,7 +4947,7 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY) { USE_OPLINE zval *args; - int arg_num; + uint32_t arg_num; SAVE_OPLINE(); args = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); @@ -4798,20 +4958,28 @@ ZEND_VM_C_LABEL(send_again): HashTable *ht = Z_ARRVAL_P(args); zval *arg, *top; zend_string *name; + zend_bool have_named_params = 0; zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht)); + // TODO: Speed this up using a flag that specifies whether there are any ref parameters. if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { - uint32_t i; + uint32_t tmp_arg_num = arg_num; int separate = 0; /* check if any of arguments are going to be passed by reference */ - for (i = 0; i < zend_hash_num_elements(ht); i++) { - if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + i)) { + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + tmp_arg_num = zend_get_arg_offset_by_name( + EX(call)->func, name, cache_slot) + 1; + } + if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) { separate = 1; break; } - } + tmp_arg_num++; + } ZEND_HASH_FOREACH_END(); if (separate) { SEPARATE_ARRAY(args); ht = Z_ARRVAL_P(args); @@ -4819,13 +4987,26 @@ ZEND_VM_C_LABEL(send_again): } ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { - if (name) { - zend_throw_error(NULL, "Cannot unpack array with string keys"); - FREE_OP1(); - HANDLE_EXCEPTION(); + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (UNEXPECTED(!top)) { + FREE_OP1(); + HANDLE_EXCEPTION(); + } + } else { + if (have_named_params) { + zend_throw_error(NULL, + "Cannot use positional argument after named argument during unpacking"); + FREE_OP1(); + HANDLE_EXCEPTION(); + } + + top = ZEND_CALL_ARG(EX(call), arg_num); + ZEND_CALL_NUM_ARGS(EX(call))++; } - top = ZEND_CALL_ARG(EX(call), arg_num); if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { if (Z_ISREF_P(arg)) { Z_ADDREF_P(arg); @@ -4842,13 +5023,13 @@ ZEND_VM_C_LABEL(send_again): ZVAL_COPY_DEREF(top, arg); } - ZEND_CALL_NUM_ARGS(EX(call))++; arg_num++; } ZEND_HASH_FOREACH_END(); } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) { zend_class_entry *ce = Z_OBJCE_P(args); zend_object_iterator *iter; + zend_bool have_named_params = 0; if (!ce || !ce->get_iterator) { zend_type_error("Only arrays and Traversables can be unpacked"); @@ -4881,6 +5062,7 @@ ZEND_VM_C_LABEL(send_again): break; } + zend_string *name = NULL; if (iter->funcs->get_current_key) { zval key; iter->funcs->get_current_key(iter, &key); @@ -4889,32 +5071,60 @@ ZEND_VM_C_LABEL(send_again): } if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE(key) != IS_STRING)) { + zend_throw_error(NULL, + "Keys must be of type int|string during argument unpacking"); + zval_ptr_dtor(&key); + break; + } + + name = Z_STR_P(&key); + } + } + + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (UNEXPECTED(!top)) { + break; + } + + if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + zend_error( + E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" + " by unpacking a Traversable, passing by-value instead", arg_num, + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? "::" : "", + ZSTR_VAL(EX(call)->func->common.function_name) + ); + } + + ZVAL_COPY_DEREF(top, arg); + zend_string_release(name); + } else { + if (have_named_params) { zend_throw_error(NULL, - (Z_TYPE(key) == IS_STRING) ? - "Cannot unpack Traversable with string keys" : - "Cannot unpack Traversable with non-integer keys"); - zval_ptr_dtor(&key); + "Cannot use positional argument after named argument during unpacking"); break; } - } - if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - zend_error( - E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" - " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name) - ); - } + if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + zend_error( + E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" + " by unpacking a Traversable, passing by-value instead", arg_num, + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? "::" : "", + ZSTR_VAL(EX(call)->func->common.function_name) + ); + } - ZVAL_DEREF(arg); - Z_TRY_ADDREF_P(arg); - zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1); - top = ZEND_CALL_ARG(EX(call), arg_num); - ZVAL_COPY_VALUE(top, arg); - ZEND_CALL_NUM_ARGS(EX(call))++; + zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1); + top = ZEND_CALL_ARG(EX(call), arg_num); + ZVAL_COPY_DEREF(top, arg); + ZEND_CALL_NUM_ARGS(EX(call))++; + } iter->funcs->move_forward(iter); } @@ -4959,10 +5169,11 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM) HashTable *ht; zval *arg, *param; - ZEND_VM_C_LABEL(send_array): ht = Z_ARRVAL_P(args); if (OP2_TYPE != IS_UNUSED) { + /* We don't need to handle named params in this case, + * because array_slice() is called with $preserve_keys == false. */ zval *op2 = GET_OP2_ZVAL_PTR(BP_VAR_R); uint32_t skip = opline->extended_value; uint32_t count = zend_hash_num_elements(ht); @@ -5007,10 +5218,28 @@ ZEND_VM_C_LABEL(send_array): } FREE_OP2(); } else { + zend_string *name; + zend_bool have_named_params; zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht)); arg_num = 1; param = ZEND_CALL_ARG(EX(call), 1); - ZEND_HASH_FOREACH_VAL(ht, arg) { + have_named_params = 0; + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { + if (name) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (!param) { + FREE_OP1(); + HANDLE_EXCEPTION(); + } + } else if (have_named_params) { + zend_throw_error(NULL, + "Cannot use positional argument after named argument"); + FREE_OP1(); + HANDLE_EXCEPTION(); + } + if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { @@ -5026,10 +5255,13 @@ ZEND_VM_C_LABEL(send_array): arg = Z_REFVAL_P(arg); } } + ZVAL_COPY(param, arg); - ZEND_CALL_NUM_ARGS(EX(call))++; - arg_num++; - param++; + if (!name) { + ZEND_CALL_NUM_ARGS(EX(call))++; + arg_num++; + param++; + } } ZEND_HASH_FOREACH_END(); } } @@ -5055,6 +5287,20 @@ ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|VAR|CV, NUM) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HOT_HANDLER(199, ZEND_CHECK_UNDEF_ARGS, UNUSED, UNUSED) +{ + USE_OPLINE + + zend_execute_data *call = execute_data->call; + if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) { + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + zend_handle_undef_args(call); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_COLD_HELPER(zend_missing_arg_helper, ANY, ANY) { #ifdef ZEND_VM_IP_GLOBAL_REG @@ -5201,6 +5447,31 @@ ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, NUM, UNUSED, CACHE_SLOT) ZVAL_EMPTY_ARRAY(params); } + if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_string *name; + zval *param; + zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args]; + if (ZEND_TYPE_IS_SET(arg_info->type)) { + SEPARATE_ARRAY(params); + ZEND_HASH_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) { + if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) { + HANDLE_EXCEPTION(); + } + Z_TRY_ADDREF_P(param); + zend_hash_add_new(Z_ARRVAL_P(params), name, param); + } ZEND_HASH_FOREACH_END(); + } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) { + GC_ADDREF(EX(extra_named_params)); + ZVAL_ARR(params, EX(extra_named_params)); + } else { + SEPARATE_ARRAY(params); + ZEND_HASH_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) { + Z_TRY_ADDREF_P(param); + zend_hash_add_new(Z_ARRVAL_P(params), name, param); + } ZEND_HASH_FOREACH_END(); + } + } + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -8117,7 +8388,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) zend_array *args = NULL; zend_function *fbc = EX(func); zval *ret = EX(return_value); - uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS); + uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS); uint32_t num_args = EX_NUM_ARGS(); zend_execute_data *call; @@ -8145,10 +8416,21 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) ZEND_CALL_NUM_ARGS(call) = 2; ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name); + + zval *call_args = ZEND_CALL_ARG(call, 2); if (args) { - ZVAL_ARR(ZEND_CALL_ARG(call, 2), args); + ZVAL_ARR(call_args, args); } else { - ZVAL_EMPTY_ARRAY(ZEND_CALL_ARG(call, 2)); + ZVAL_EMPTY_ARRAY(call_args); + } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) { + GC_ADDREF(call->extra_named_params); + ZVAL_ARR(call_args, call->extra_named_params); + } else { + SEPARATE_ARRAY(call_args); + zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref); + } } zend_free_trampoline(fbc); fbc = call->func; @@ -9187,7 +9469,7 @@ ZEND_VM_C_LABEL(fetch_dim_r_index_undef): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR, (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_SIMPLE, CV|VAR, NUM) +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR, op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_SIMPLE, CV|VAR, NUM) { USE_OPLINE zval *varptr, *arg; @@ -9204,7 +9486,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR, (op1_info & (MAY_BE_UNDEF|MAY_BE_RE ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR_EX, op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_EX_SIMPLE, CV|VAR, NUM) +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR_EX, op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_EX_SIMPLE, CV|VAR, UNUSED|NUM) { USE_OPLINE zval *varptr, *arg; @@ -9226,7 +9508,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR_EX, op->op2.num <= MAX_ARG_FLAG_NUM ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL, op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_SIMPLE, CONST, NUM) +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL, op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_SIMPLE, CONST, NUM) { USE_OPLINE zval *value, *arg; @@ -9237,7 +9519,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL, op->op1_type == IS_CONST && !Z_REFC ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL_EX, op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_EX_SIMPLE, CONST, NUM) +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL_EX, op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_EX_SIMPLE, CONST, NUM) { USE_OPLINE zval *value, *arg; diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 3e6edeb8df..4f118764a8 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1085,7 +1085,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -1118,6 +1118,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper zend_clean_and_cache_symbol_table(EX(symbol_table)); } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } + /* Free extra args before releasing the closure, * as that may free the op_array. */ zend_vm_stack_free_extra_args_ex(call_info, execute_data); @@ -1165,11 +1169,14 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper #ifdef ZEND_PREFER_RELOAD call_info = EX_CALL_INFO(); #endif - if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) { + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) { if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_clean_and_cache_symbol_table(EX(symbol_table)); } zend_vm_stack_free_extra_args_ex(call_info, execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } } if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); @@ -1239,7 +1246,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETV EG(current_execute_data) = execute_data; zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!0) { i_zval_ptr_dtor(ret); @@ -1291,7 +1307,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETV EG(current_execute_data) = execute_data; zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!1) { i_zval_ptr_dtor(ret); @@ -1418,7 +1443,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S fcall_by_name_end: zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!0) { i_zval_ptr_dtor(ret); @@ -1499,7 +1533,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S fcall_by_name_end: zend_vm_stack_free_args(call); - zend_vm_stack_free_call_frame(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } if (!1) { i_zval_ptr_dtor(ret); @@ -1593,6 +1636,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV fcall_end: zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(call->extra_named_params); + } + if (!0) { i_zval_ptr_dtor(ret); } @@ -1691,6 +1738,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV fcall_end: zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(call->extra_named_params); + } + if (!1) { i_zval_ptr_dtor(ret); } @@ -1804,7 +1855,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ { USE_OPLINE zval *args; - int arg_num; + uint32_t arg_num; SAVE_OPLINE(); args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); @@ -1815,20 +1866,28 @@ send_again: HashTable *ht = Z_ARRVAL_P(args); zval *arg, *top; zend_string *name; + zend_bool have_named_params = 0; zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht)); + // TODO: Speed this up using a flag that specifies whether there are any ref parameters. if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { - uint32_t i; + uint32_t tmp_arg_num = arg_num; int separate = 0; /* check if any of arguments are going to be passed by reference */ - for (i = 0; i < zend_hash_num_elements(ht); i++) { - if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + i)) { + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + tmp_arg_num = zend_get_arg_offset_by_name( + EX(call)->func, name, cache_slot) + 1; + } + if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) { separate = 1; break; } - } + tmp_arg_num++; + } ZEND_HASH_FOREACH_END(); if (separate) { SEPARATE_ARRAY(args); ht = Z_ARRVAL_P(args); @@ -1836,13 +1895,26 @@ send_again: } ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { - if (name) { - zend_throw_error(NULL, "Cannot unpack array with string keys"); - FREE_OP(opline->op1_type, opline->op1.var); - HANDLE_EXCEPTION(); + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (UNEXPECTED(!top)) { + FREE_OP(opline->op1_type, opline->op1.var); + HANDLE_EXCEPTION(); + } + } else { + if (have_named_params) { + zend_throw_error(NULL, + "Cannot use positional argument after named argument during unpacking"); + FREE_OP(opline->op1_type, opline->op1.var); + HANDLE_EXCEPTION(); + } + + top = ZEND_CALL_ARG(EX(call), arg_num); + ZEND_CALL_NUM_ARGS(EX(call))++; } - top = ZEND_CALL_ARG(EX(call), arg_num); if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { if (Z_ISREF_P(arg)) { Z_ADDREF_P(arg); @@ -1859,13 +1931,13 @@ send_again: ZVAL_COPY_DEREF(top, arg); } - ZEND_CALL_NUM_ARGS(EX(call))++; arg_num++; } ZEND_HASH_FOREACH_END(); } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) { zend_class_entry *ce = Z_OBJCE_P(args); zend_object_iterator *iter; + zend_bool have_named_params = 0; if (!ce || !ce->get_iterator) { zend_type_error("Only arrays and Traversables can be unpacked"); @@ -1898,6 +1970,7 @@ send_again: break; } + zend_string *name = NULL; if (iter->funcs->get_current_key) { zval key; iter->funcs->get_current_key(iter, &key); @@ -1906,32 +1979,60 @@ send_again: } if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) { + if (UNEXPECTED(Z_TYPE(key) != IS_STRING)) { + zend_throw_error(NULL, + "Keys must be of type int|string during argument unpacking"); + zval_ptr_dtor(&key); + break; + } + + name = Z_STR_P(&key); + } + } + + if (UNEXPECTED(name)) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (UNEXPECTED(!top)) { + break; + } + + if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + zend_error( + E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" + " by unpacking a Traversable, passing by-value instead", arg_num, + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? "::" : "", + ZSTR_VAL(EX(call)->func->common.function_name) + ); + } + + ZVAL_COPY_DEREF(top, arg); + zend_string_release(name); + } else { + if (have_named_params) { zend_throw_error(NULL, - (Z_TYPE(key) == IS_STRING) ? - "Cannot unpack Traversable with string keys" : - "Cannot unpack Traversable with non-integer keys"); - zval_ptr_dtor(&key); + "Cannot use positional argument after named argument during unpacking"); break; } - } - if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - zend_error( - E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" - " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name) - ); - } + if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + zend_error( + E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" + " by unpacking a Traversable, passing by-value instead", arg_num, + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? "::" : "", + ZSTR_VAL(EX(call)->func->common.function_name) + ); + } - ZVAL_DEREF(arg); - Z_TRY_ADDREF_P(arg); - zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1); - top = ZEND_CALL_ARG(EX(call), arg_num); - ZVAL_COPY_VALUE(top, arg); - ZEND_CALL_NUM_ARGS(EX(call))++; + zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1); + top = ZEND_CALL_ARG(EX(call), arg_num); + ZVAL_COPY_DEREF(top, arg); + ZEND_CALL_NUM_ARGS(EX(call))++; + } iter->funcs->move_forward(iter); } @@ -1976,10 +2077,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O HashTable *ht; zval *arg, *param; - send_array: ht = Z_ARRVAL_P(args); if (opline->op2_type != IS_UNUSED) { + /* We don't need to handle named params in this case, + * because array_slice() is called with $preserve_keys == false. */ zval *op2 = get_zval_ptr(opline->op2_type, opline->op2, BP_VAR_R); uint32_t skip = opline->extended_value; uint32_t count = zend_hash_num_elements(ht); @@ -2024,10 +2126,28 @@ send_array: } FREE_OP(opline->op2_type, opline->op2.var); } else { + zend_string *name; + zend_bool have_named_params; zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht)); arg_num = 1; param = ZEND_CALL_ARG(EX(call), 1); - ZEND_HASH_FOREACH_VAL(ht, arg) { + have_named_params = 0; + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { + if (name) { + void *cache_slot[2] = {NULL, NULL}; + have_named_params = 1; + param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); + if (!param) { + FREE_OP(opline->op1_type, opline->op1.var); + HANDLE_EXCEPTION(); + } + } else if (have_named_params) { + zend_throw_error(NULL, + "Cannot use positional argument after named argument"); + FREE_OP(opline->op1_type, opline->op1.var); + HANDLE_EXCEPTION(); + } + if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { if (UNEXPECTED(!Z_ISREF_P(arg))) { if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { @@ -2043,10 +2163,13 @@ send_array: arg = Z_REFVAL_P(arg); } } + ZVAL_COPY(param, arg); - ZEND_CALL_NUM_ARGS(EX(call))++; - arg_num++; - param++; + if (!name) { + ZEND_CALL_NUM_ARGS(EX(call))++; + arg_num++; + param++; + } } ZEND_HASH_FOREACH_END(); } } @@ -2702,7 +2825,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z zend_array *args = NULL; zend_function *fbc = EX(func); zval *ret = EX(return_value); - uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS); + uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS); uint32_t num_args = EX_NUM_ARGS(); zend_execute_data *call; @@ -2730,10 +2853,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z ZEND_CALL_NUM_ARGS(call) = 2; ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name); + + zval *call_args = ZEND_CALL_ARG(call, 2); if (args) { - ZVAL_ARR(ZEND_CALL_ARG(call, 2), args); + ZVAL_ARR(call_args, args); } else { - ZVAL_EMPTY_ARRAY(ZEND_CALL_ARG(call, 2)); + ZVAL_EMPTY_ARRAY(call_args); + } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) { + GC_ADDREF(call->extra_named_params); + ZVAL_ARR(call_args, call->extra_named_params); + } else { + SEPARATE_ARRAY(call_args); + zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref); + } } zend_free_trampoline(fbc); fbc = call->func; @@ -3151,6 +3285,31 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HAND ZVAL_EMPTY_ARRAY(params); } + if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_string *name; + zval *param; + zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args]; + if (ZEND_TYPE_IS_SET(arg_info->type)) { + SEPARATE_ARRAY(params); + ZEND_HASH_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) { + if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) { + HANDLE_EXCEPTION(); + } + Z_TRY_ADDREF_P(param); + zend_hash_add_new(Z_ARRVAL_P(params), name, param); + } ZEND_HASH_FOREACH_END(); + } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) { + GC_ADDREF(EX(extra_named_params)); + ZVAL_ARR(params, EX(extra_named_params)); + } else { + SEPARATE_ARRAY(params); + ZEND_HASH_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) { + Z_TRY_ADDREF_P(param); + zend_hash_add_new(Z_ARRVAL_P(params), name, param); + } ZEND_HASH_FOREACH_END(); + } + } + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -3711,72 +3870,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - - value = RT_CONSTANT(opline, opline->op1); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref: - ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - value = RT_CONSTANT(opline, opline->op1); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref: - ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - value = RT_CONSTANT(opline, opline->op1); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -5937,6 +6030,69 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = RT_CONSTANT(opline, opline->op1); + ZVAL_COPY_VALUE(arg, value); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = RT_CONSTANT(opline, opline->op1); + ZVAL_COPY_VALUE(arg, value); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -8895,6 +9051,105 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYP } } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = RT_CONSTANT(opline, opline->op1); + ZVAL_COPY_VALUE(arg, value); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = RT_CONSTANT(opline, opline->op1); + ZVAL_COPY_VALUE(arg, value); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = RT_CONSTANT(opline, opline->op1); + ZVAL_COPY_VALUE(arg, value); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -13157,22 +13412,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND HANDLE_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -14599,6 +14838,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -16362,6 +16628,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HA } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17639,56 +17932,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HAND ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref: - ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref: - ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -18258,6 +18501,42 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLE ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -19045,6 +19324,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN } } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref: + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20126,290 +20477,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HAND ZEND_VM_RETURN(); } -static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_VAR == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - - if (EXPECTED(Z_ISREF_P(varptr))) { - ZEND_VM_NEXT_OPCODE(); - } - - SAVE_OPLINE(); - ZVAL_NEW_REF(arg, arg); - zend_error(E_NOTICE, "Only variables should be passed by reference"); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - - if (EXPECTED(Z_ISREF_P(varptr) || - QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - ZEND_VM_NEXT_OPCODE(); - } - } else { - if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - - if (EXPECTED(Z_ISREF_P(varptr) || - ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - ZEND_VM_NEXT_OPCODE(); - } - } - - SAVE_OPLINE(); - ZVAL_NEW_REF(arg, arg); - zend_error(E_NOTICE, "Only variables should be passed by reference"); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - - if (EXPECTED(Z_ISREF_P(varptr) || - QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - ZEND_VM_NEXT_OPCODE(); - } - } else { - if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_COPY_VALUE(arg, varptr); - - if (EXPECTED(Z_ISREF_P(varptr) || - ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - ZEND_VM_NEXT_OPCODE(); - } - } - - SAVE_OPLINE(); - ZVAL_NEW_REF(arg, arg); - zend_error(E_NOTICE, "Only variables should be passed by reference"); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - SAVE_OPLINE(); - varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - if (Z_ISREF_P(varptr)) { - Z_ADDREF_P(varptr); - } else { - ZVAL_MAKE_REF_EX(varptr, 2); - } - ZVAL_REF(arg, Z_REF_P(varptr)); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_VAR == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_VAR == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21150,28 +21217,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SP ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_VAR == IS_CV) { - ZVAL_COPY(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - ZVAL_COPY_VALUE(arg, varptr); - } - - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -22993,6 +23038,294 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr))) { + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + ZVAL_NEW_REF(arg, arg); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } else { + if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + ZVAL_NEW_REF(arg, arg); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + +send_var: + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + SAVE_OPLINE(); + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_CONST == IS_CONST) { + // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -26575,6 +26908,427 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN } } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr))) { + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + ZVAL_NEW_REF(arg, arg); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } else { + if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + ZVAL_NEW_REF(arg, arg); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + +send_var: + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } else { + if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var; + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, varptr); + + if (EXPECTED(Z_ISREF_P(varptr) || + ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + ZVAL_NEW_REF(arg, arg); + zend_error(E_NOTICE, "Only variables should be passed by reference"); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + +send_var: + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + SAVE_OPLINE(); + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_UNUSED == IS_CONST) { + // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -26951,6 +27705,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num = opline->op2.num; + + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + + if (IS_VAR == IS_CV) { + ZVAL_COPY(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + ZVAL_COPY_VALUE(arg, varptr); + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -29254,44 +30030,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_ } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } else { - ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } else { - ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } else { - ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } else { - ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -30959,6 +31697,38 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg_num = zend_get_arg_offset_by_name( + EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1; + if (UNEXPECTED(arg_num == 0)) { + /* Treat this as a by-value argument, and throw an error during SEND. */ + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + ZEND_VM_NEXT_OPCODE(); + } + } else { + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33303,6 +34073,84 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED } } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg_num = zend_get_arg_offset_by_name( + EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1; + if (UNEXPECTED(arg_num == 0)) { + /* Treat this as a by-value argument, and throw an error during SEND. */ + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + ZEND_VM_NEXT_OPCODE(); + } + } else { + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg_num = zend_get_arg_offset_by_name( + EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1; + if (UNEXPECTED(arg_num == 0)) { + /* Treat this as a by-value argument, and throw an error during SEND. */ + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + ZEND_VM_NEXT_OPCODE(); + } + } else { + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } else { + ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zend_execute_data *call = execute_data->call; + if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) { + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + zend_handle_undef_args(call); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -36126,161 +36974,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPC HANDLE_EXCEPTION(); } -static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - varptr = EX_VAR(opline->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_CV == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_CV == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_CV_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - - SAVE_OPLINE(); - varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - if (Z_ISREF_P(varptr)) { - Z_ADDREF_P(varptr); - } else { - ZVAL_MAKE_REF_EX(varptr, 2); - } - ZVAL_REF(arg, Z_REF_P(varptr)); - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(0)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = EX_VAR(opline->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_CV == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_CV == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (EXPECTED(1)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = EX_VAR(opline->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_CV == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_CV == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -37234,28 +37927,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SP ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num = opline->op2.num; - - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - varptr = EX_VAR(opline->op1.var); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - - if (IS_CV == IS_CV) { - ZVAL_COPY(arg, varptr); - } else /* if (IS_CV == IS_VAR) */ { - ZVAL_COPY_VALUE(arg, varptr); - } - - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -39929,6 +40600,145 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = EX_VAR(opline->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + SAVE_OPLINE(); + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + ZEND_VM_NEXT_OPCODE(); + } + + varptr = EX_VAR(opline->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -44892,6 +45702,210 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU } } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = EX_VAR(opline->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + + SAVE_OPLINE(); + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(0)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + ZEND_VM_NEXT_OPCODE(); + } + + varptr = EX_VAR(opline->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + ZEND_VM_NEXT_OPCODE(); + } + + varptr = EX_VAR(opline->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -45540,6 +46554,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num = opline->op2.num; + + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + + varptr = EX_VAR(opline->op1.var); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + + if (IS_CV == IS_CV) { + ZVAL_COPY(arg, varptr); + } else /* if (IS_CV == IS_VAR) */ { + ZVAL_COPY_VALUE(arg, varptr); + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -50135,8 +51171,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL, - (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_LABEL, - (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CAST_SPEC_CONST_LABEL, (void*)&&ZEND_CAST_SPEC_TMP_LABEL, (void*)&&ZEND_CAST_SPEC_VAR_LABEL, @@ -50200,26 +51244,106 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RETURN_SPEC_CV_LABEL, (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL, (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL, - (void*)&&ZEND_SEND_VAL_SPEC_CONST_LABEL, - (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_LABEL, - (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_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_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_SEND_VAR_EX_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_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_SEND_VAR_EX_SPEC_VAR_LABEL, - (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_LABEL, - (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_QUICK_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_REF_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_REF_SPEC_CV_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_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_SEND_REF_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_REF_SPEC_VAR_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_SEND_REF_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL, @@ -50700,14 +51824,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL, (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_LABEL, - (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK_LABEL, + (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL, + (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_EXT_STMT_SPEC_LABEL, (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL, (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL, (void*)&&ZEND_EXT_NOP_SPEC_LABEL, (void*)&&ZEND_TICKS_SPEC_LABEL, - (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CATCH_SPEC_CONST_LABEL, (void*)&&ZEND_THROW_SPEC_CONST_LABEL, (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL, @@ -50809,10 +51945,56 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL, - (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_LABEL, - (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_QUICK_LABEL, - (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_LABEL, - (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_QUICK_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL, + (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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, @@ -50821,9 +52003,23 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_VAR_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_VAR_SPEC_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_SPEC_VAR_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_SEND_VAR_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, @@ -51105,7 +52301,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL, (void*)&&ZEND_BIND_STATIC_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL, - (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_LABEL, + (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL, @@ -51203,6 +52403,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, + (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52099,9 +53300,9 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_LABEL, + (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL, (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL, (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL, @@ -52196,7 +53397,7 @@ zend_leave_helper_SPEC_LABEL: uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -52229,6 +53430,10 @@ zend_leave_helper_SPEC_LABEL: zend_clean_and_cache_symbol_table(EX(symbol_table)); } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } + /* Free extra args before releasing the closure, * as that may free the op_array. */ zend_vm_stack_free_extra_args_ex(call_info, execute_data); @@ -52276,11 +53481,14 @@ zend_leave_helper_SPEC_LABEL: #ifdef ZEND_PREFER_RELOAD call_info = EX_CALL_INFO(); #endif - if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) { + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) { if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_clean_and_cache_symbol_table(EX(symbol_table)); } zend_vm_stack_free_extra_args_ex(call_info, execute_data); + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } } if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); @@ -52599,18 +53807,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_CATCH_SPEC_CONST) ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST): - VM_TRACE(ZEND_SEND_VAL_SPEC_CONST) - ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST): - VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST) - ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_QUICK): - VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_QUICK) - ZEND_SEND_VAL_EX_SPEC_CONST_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST): VM_TRACE(ZEND_SEND_USER_SPEC_CONST) ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -52815,6 +54011,14 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST) ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST): + VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST) + ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST) + ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST): VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53095,6 +54299,18 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED) + ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) + ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) + ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED): VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED) ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53699,10 +54915,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_THROW_SPEC_TMPVAR) ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR): - VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR) - ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR): VM_TRACE(ZEND_BOOL_SPEC_TMPVAR) ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53799,6 +55011,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST) + ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST) ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53939,6 +55155,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) + ZEND_SEND_VAL_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); @@ -54100,14 +55320,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP) ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP): - VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP) - ZEND_SEND_VAL_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_QUICK): - VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_QUICK) - ZEND_SEND_VAL_EX_SPEC_TMP_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP): VM_TRACE(ZEND_SEND_USER_SPEC_TMP) ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54168,6 +55380,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST) ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST) + ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54236,6 +55452,14 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) + ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK): + VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) + ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54393,38 +55617,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR) ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR): - VM_TRACE(ZEND_SEND_VAR_SPEC_VAR) - ZEND_SEND_VAR_SPEC_VAR_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR): - VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR) - ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR): - VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR) - ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK): - VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK) - ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR): - VM_TRACE(ZEND_SEND_REF_SPEC_VAR) - ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR): - VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR) - ZEND_SEND_VAR_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_QUICK): - VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_QUICK) - ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR): - VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR) - ZEND_SEND_FUNC_ARG_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR): VM_TRACE(ZEND_SEND_USER_SPEC_VAR) ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54465,10 +55657,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR) ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR): - VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) - ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST): VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST) ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54589,6 +55777,30 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST) + ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) + ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST) + ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST) + ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST): + VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) + ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST): VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54821,6 +56033,38 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED) + ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) + ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED) + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK): + VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK) + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED) + ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) + ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) + ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) + ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED): VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED) ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54849,6 +56093,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED) ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) + ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV): VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV) ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54993,14 +56241,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED): - VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED) - ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK): - VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK) - ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED): VM_TRACE(ZEND_CLONE_SPEC_UNUSED) ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55085,6 +56325,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST): + VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST): VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55213,6 +56457,18 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED): + VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK): + VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED): + VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) + ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED) ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55478,22 +56734,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_THROW_SPEC_CV) ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV): - VM_TRACE(ZEND_SEND_VAR_SPEC_CV) - ZEND_SEND_VAR_SPEC_CV_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_REF_SPEC_CV): - VM_TRACE(ZEND_SEND_REF_SPEC_CV) - ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV): - VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV) - ZEND_SEND_VAR_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_QUICK): - VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_QUICK) - ZEND_SEND_VAR_EX_SPEC_CV_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_CV): VM_TRACE(ZEND_SEND_USER_SPEC_CV) ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55602,10 +56842,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV) ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV): - VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) - ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST): VM_TRACE(ZEND_DIV_SPEC_CV_CONST) ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55782,6 +57018,18 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST): + VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST) + ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST): + VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST) + ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST) + ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56134,6 +57382,22 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED): + VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED) + ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED): + VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED) + ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) + ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK): + VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) + ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56194,6 +57458,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED) ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED): + VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) + ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_DIV_SPEC_CV_CV): VM_TRACE(ZEND_DIV_SPEC_CV_CV) ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57775,8 +59043,16 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_CASE_SPEC_TMPVAR_CV_HANDLER, ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER, - ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HANDLER, - ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_HANDLER, + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER, + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER, + ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_CAST_SPEC_CONST_HANDLER, ZEND_CAST_SPEC_TMP_HANDLER, ZEND_CAST_SPEC_VAR_HANDLER, @@ -57840,26 +59116,106 @@ void zend_vm_init(void) ZEND_RETURN_SPEC_CV_HANDLER, ZEND_RECV_SPEC_UNUSED_HANDLER, ZEND_RECV_INIT_SPEC_CONST_HANDLER, - ZEND_SEND_VAL_SPEC_CONST_HANDLER, - ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER, - ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER, + ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_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_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER, + ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER, + ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_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_SEND_VAR_EX_SPEC_CV_CONST_HANDLER, + ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER, + ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_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_SEND_VAR_EX_SPEC_VAR_HANDLER, - ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_HANDLER, ZEND_NULL_HANDLER, + ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_VAR_EX_SPEC_CV_HANDLER, - ZEND_SEND_VAR_EX_SPEC_CV_QUICK_HANDLER, ZEND_NULL_HANDLER, + ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_REF_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_REF_SPEC_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_REF_SPEC_CV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER, + ZEND_NULL_HANDLER, ZEND_NEW_SPEC_CONST_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_NEW_SPEC_VAR_UNUSED_HANDLER, @@ -58340,14 +59696,26 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER, - ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_HANDLER, - ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK_HANDLER, + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER, + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER, + ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_EXT_STMT_SPEC_HANDLER, ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER, ZEND_EXT_FCALL_END_SPEC_HANDLER, ZEND_EXT_NOP_SPEC_HANDLER, ZEND_TICKS_SPEC_HANDLER, - ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER, + ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER, + ZEND_NULL_HANDLER, ZEND_CATCH_SPEC_CONST_HANDLER, ZEND_THROW_SPEC_CONST_HANDLER, ZEND_THROW_SPEC_TMPVAR_HANDLER, @@ -58449,10 +59817,35 @@ void zend_vm_init(void) ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER, - ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER, - ZEND_SEND_VAL_EX_SPEC_CONST_QUICK_HANDLER, - ZEND_SEND_VAL_EX_SPEC_TMP_HANDLER, - ZEND_SEND_VAL_EX_SPEC_TMP_QUICK_HANDLER, + ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER, + ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER, + ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER, + ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER, + ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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, @@ -58461,9 +59854,44 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_VAR_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_VAR_SPEC_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_SEND_VAR_SPEC_VAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER, + ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, @@ -58745,7 +60173,11 @@ void zend_vm_init(void) ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER, ZEND_BIND_STATIC_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER, - ZEND_SEND_FUNC_ARG_SPEC_VAR_HANDLER, + ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER, + ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER, @@ -58843,6 +60275,7 @@ void zend_vm_init(void) ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, ZEND_NULL_HANDLER, ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, + ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -59739,9 +61172,9 @@ void zend_vm_init(void) ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_HANDLER, + ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_HANDLER, + ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER, ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER, @@ -59799,156 +61232,157 @@ void zend_vm_init(void) 1276 | SPEC_RULE_OP1, 1281 | SPEC_RULE_OP2, 1286, - 1287 | SPEC_RULE_QUICK_ARG, - 1289 | SPEC_RULE_OP1, - 1294 | SPEC_RULE_OP1, - 1299 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1324 | SPEC_RULE_OP2, - 1329 | SPEC_RULE_OP2, - 1334 | SPEC_RULE_OP2, - 1339, - 1340, - 1341, - 1342 | SPEC_RULE_RETVAL, - 1344, - 1345 | SPEC_RULE_OP1, - 1350, - 1351, - 1352 | SPEC_RULE_OP1, - 1357 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG, - 1367 | SPEC_RULE_OP1, - 1372 | SPEC_RULE_OP1, - 1377, - 1378, - 1379 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1404 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1429 | SPEC_RULE_OP1, - 1434 | SPEC_RULE_OP1, - 1439 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1464 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1489 | SPEC_RULE_OP1, - 1494, - 1495, - 1496 | SPEC_RULE_OP1, - 1501 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1526 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1551 | SPEC_RULE_OP1, - 1556 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1581 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1606 | SPEC_RULE_OP1, - 1611 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1636 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1661 | SPEC_RULE_OP1, - 1666 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1691 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1716 | SPEC_RULE_OP1, - 1721 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1746 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1771 | SPEC_RULE_OP1, - 1776 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1801 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1826 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1851, - 1852 | SPEC_RULE_QUICK_ARG, - 1854, - 1855, - 1856, - 1857, - 1858, - 1859, - 1860, - 1861 | SPEC_RULE_OP1, - 1866 | SPEC_RULE_OP2, - 1871 | SPEC_RULE_OP1, - 1876 | SPEC_RULE_OP1, - 1881 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1906 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1931 | SPEC_RULE_OP1, - 1936 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1961 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG, + 1287 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1297 | SPEC_RULE_OP1, + 1302 | SPEC_RULE_OP1, + 1307 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1332 | SPEC_RULE_OP2, + 1337 | SPEC_RULE_OP2, + 1342 | SPEC_RULE_OP2, + 1347, + 1348, + 1349, + 1350 | SPEC_RULE_RETVAL, + 1352, + 1353 | SPEC_RULE_OP1, + 1358, + 1359, + 1360 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1385 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1435 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1460 | SPEC_RULE_OP1, + 1465, + 1466, + 1467 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1492 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1517 | SPEC_RULE_OP1, + 1522 | SPEC_RULE_OP1, + 1527 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1552 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1577 | SPEC_RULE_OP1, + 1582, + 1583, + 1584 | SPEC_RULE_OP1, + 1589 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1614 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1639 | SPEC_RULE_OP1, + 1644 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1669 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1694 | SPEC_RULE_OP1, + 1699 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1724 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1749 | SPEC_RULE_OP1, + 1754 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1779 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1804 | SPEC_RULE_OP1, + 1809 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1834 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1859 | SPEC_RULE_OP1, + 1864 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1889 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1914 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1939, + 1940 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1950, + 1951, + 1952, + 1953, + 1954, + 1955 | SPEC_RULE_OP2, + 1960, + 1961 | SPEC_RULE_OP1, + 1966 | SPEC_RULE_OP2, 1971 | SPEC_RULE_OP1, - 1976 | SPEC_RULE_OP2, - 1981, - 1982 | SPEC_RULE_OP1, - 1987 | SPEC_RULE_OP1, - 1992, - 1993 | SPEC_RULE_OP1, - 1998 | SPEC_RULE_OP1, - 2003 | SPEC_RULE_OP1, - 2008, - 2009, - 2010 | SPEC_RULE_OP2, - 2015 | SPEC_RULE_RETVAL, - 2017 | SPEC_RULE_RETVAL, - 2019 | SPEC_RULE_RETVAL, - 2021 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2021 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2046 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2046 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2071 | SPEC_RULE_OP1, - 2076, - 2077 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2102, - 2103 | SPEC_RULE_OP1, - 2108, - 2109, - 2110, - 2111, - 2112, - 2113, - 2114, - 2115 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2140, + 1976 | SPEC_RULE_OP1, + 1981 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2006 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2031 | SPEC_RULE_OP1, + 2036 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2061 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2111 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2136 | SPEC_RULE_OP2, 2141, - 2142, - 2143 | SPEC_RULE_OP1, - 2148, - 2149 | SPEC_RULE_ISSET, - 2151 | SPEC_RULE_OP2, - 2156, - 2157 | SPEC_RULE_OP1, - 2162, - 2163, - 2164 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2189 | SPEC_RULE_OP1, - 2194, - 2195, - 2196, - 2197, - 2198 | SPEC_RULE_OP1, - 2203, - 2204, - 2205 | SPEC_RULE_OP1, - 2210 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2235, - 2236 | SPEC_RULE_OP1, - 2241, - 2242, - 2243, - 2244, - 2245, - 2246, - 2247, - 2248, - 2249 | SPEC_RULE_OP1, - 2254, - 2255, - 2256, - 2257, - 2258, - 2259 | SPEC_RULE_OP1, - 2264 | SPEC_RULE_OP1, - 2269 | SPEC_RULE_OP1, - 2274 | SPEC_RULE_OP1, - 2279 | SPEC_RULE_OP1, - 2284, - 2285 | SPEC_RULE_OP1, - 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2315 | SPEC_RULE_OP1, - 2320 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2345 | SPEC_RULE_OP1, - 2350 | SPEC_RULE_OP1, - 3258 + 2142 | SPEC_RULE_OP1, + 2147 | SPEC_RULE_OP1, + 2152, + 2153 | SPEC_RULE_OP1, + 2158 | SPEC_RULE_OP1, + 2163 | SPEC_RULE_OP1, + 2168, + 2169, + 2170 | SPEC_RULE_OP2, + 2175 | SPEC_RULE_RETVAL, + 2177 | SPEC_RULE_RETVAL, + 2179 | SPEC_RULE_RETVAL, + 2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2231 | SPEC_RULE_OP1, + 2236, + 2237 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2262, + 2263 | SPEC_RULE_OP1, + 2268, + 2269, + 2270, + 2271, + 2272, + 2273, + 2274, + 2275 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2300, + 2301, + 2302, + 2303 | SPEC_RULE_OP1, + 2308, + 2309 | SPEC_RULE_ISSET, + 2311 | SPEC_RULE_OP2, + 2316, + 2317 | SPEC_RULE_OP1, + 2322, + 2323, + 2324 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2349 | SPEC_RULE_OP1, + 2354, + 2355, + 2356, + 2357, + 2358 | SPEC_RULE_OP1, + 2363, + 2364, + 2365 | SPEC_RULE_OP1, + 2370 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2395, + 2396 | SPEC_RULE_OP1, + 2401, + 2402, + 2403, + 2404, + 2405, + 2406, + 2407, + 2408, + 2409 | SPEC_RULE_OP1, + 2414, + 2415, + 2416, + 2417 | SPEC_RULE_OP2, + 2422, + 2423 | SPEC_RULE_OP1, + 2428 | SPEC_RULE_OP1, + 2433 | SPEC_RULE_OP1, + 2438 | SPEC_RULE_OP1, + 2443 | SPEC_RULE_OP1, + 2448, + 2449 | SPEC_RULE_OP1, + 2454 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2479 | SPEC_RULE_OP1, + 2484 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2509 | SPEC_RULE_OP1, + 2514 | SPEC_RULE_OP1, + 2519, + 3423 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -60113,7 +61547,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 = 2357 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60121,7 +61555,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 = 2382 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60129,7 +61563,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 = 2407 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60140,17 +61574,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 = 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2597 | 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 = 2457 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2622 | 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 = 2482 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -60161,17 +61595,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 = 2507 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2672 | 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 = 2532 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2697 | 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 = 2557 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -60182,14 +61616,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2582 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2657 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 2882 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -60200,14 +61634,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2732 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | 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 = 2807 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 2887 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -60218,12 +61652,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 = 2582 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2657 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -60234,12 +61668,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 = 2732 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | 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 = 2807 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -60247,12 +61681,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 = 2892 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3057 | 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 = 2967 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3132 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -60260,74 +61694,74 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3042 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3207 | 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 = 3117 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3282 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3204 | SPEC_RULE_OP1; + spec = 3369 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3209 | SPEC_RULE_OP1; + spec = 3374 | SPEC_RULE_OP1; } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { - spec = 3214 | SPEC_RULE_OP1; + spec = 3379 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3192 | SPEC_RULE_RETVAL; + spec = 3357 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3194 | SPEC_RULE_RETVAL; + spec = 3359 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3196 | SPEC_RULE_RETVAL; + spec = 3361 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3198 | SPEC_RULE_RETVAL; + spec = 3363 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3200; + spec = 3365; } else if (op1_info == MAY_BE_LONG) { - spec = 3201; + spec = 3366; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3202; + spec = 3367; } else if (op1_info == MAY_BE_LONG) { - spec = 3203; + spec = 3368; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2356; + spec = 2521; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2355; + spec = 2520; } break; case ZEND_SEND_VAL: - if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3254; + if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { + spec = 3419; } break; case ZEND_SEND_VAR_EX: - if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3249 | SPEC_RULE_OP1; + if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { + spec = 3414 | 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 = 3256 | SPEC_RULE_RETVAL; + spec = 3421 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -60335,17 +61769,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 = 3219 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3384 | 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 = 3255; + if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { + spec = 3420; } break; case ZEND_SEND_VAR: - if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3244 | SPEC_RULE_OP1; + if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { + spec = 3409 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index ae1da5d2e8..aa70a63113 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -1015,6 +1015,17 @@ function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno, } } + /* Skip QUICK_ARG specialization for named parameters */ + if (isset($extra_spec["QUICK_ARG"])) { + if ($op2 === "CONST") { + if ($extra_spec["QUICK_ARG"] == 0) { + unset($extra_spec["QUICK_ARG"]); + } else { + return; + } + } + } + if (ZEND_VM_LINES) { out($f, "#line $lineno \"$definition_file\"\n"); } @@ -1335,6 +1346,13 @@ function gen_labels($f, $spec, $kind, $prolog, &$specs, $switch_labels = array() } } + /* Skip QUICK_ARG specialization for named parameters */ + if (isset($extra_spec["QUICK_ARG"])) { + if ($op2 === "CONST") { + unset($extra_spec["QUICK_ARG"]); + } + } + // Emit pointer to specialized handler $spec_name = $dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2].extra_spec_name($extra_spec); switch ($kind) { diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index e4eb020539..afcc07a8fd 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -592,1213 +592,1235 @@ _(1283, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \ _(1285, ZEND_CASE_SPEC_TMPVAR_CV) \ _(1286, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \ - _(1287, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR) \ - _(1288, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK) \ - _(1289, ZEND_CAST_SPEC_CONST) \ - _(1290, ZEND_CAST_SPEC_TMP) \ - _(1291, ZEND_CAST_SPEC_VAR) \ - _(1293, ZEND_CAST_SPEC_CV) \ - _(1294, ZEND_BOOL_SPEC_CONST) \ - _(1295, ZEND_BOOL_SPEC_TMPVAR) \ - _(1296, ZEND_BOOL_SPEC_TMPVAR) \ - _(1298, ZEND_BOOL_SPEC_CV) \ - _(1299, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ - _(1300, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ - _(1301, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ - _(1303, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ - _(1304, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ - _(1305, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1306, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1308, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ - _(1309, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ - _(1310, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1311, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1313, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ - _(1319, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ - _(1320, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ - _(1321, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ - _(1323, ZEND_FAST_CONCAT_SPEC_CV_CV) \ - _(1324, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ - _(1325, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ - _(1326, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ - _(1328, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ - _(1329, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ - _(1330, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ - _(1331, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ - _(1333, ZEND_ROPE_ADD_SPEC_TMP_CV) \ - _(1334, ZEND_ROPE_END_SPEC_TMP_CONST) \ - _(1335, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ - _(1336, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ - _(1338, ZEND_ROPE_END_SPEC_TMP_CV) \ - _(1339, ZEND_BEGIN_SILENCE_SPEC) \ - _(1340, ZEND_END_SILENCE_SPEC_TMP) \ - _(1341, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ - _(1342, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ - _(1343, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ - _(1344, ZEND_INIT_FCALL_SPEC_CONST) \ - _(1345, ZEND_RETURN_SPEC_CONST) \ - _(1346, ZEND_RETURN_SPEC_TMP) \ - _(1347, ZEND_RETURN_SPEC_VAR) \ - _(1349, ZEND_RETURN_SPEC_CV) \ - _(1350, ZEND_RECV_SPEC_UNUSED) \ - _(1351, ZEND_RECV_INIT_SPEC_CONST) \ - _(1352, ZEND_SEND_VAL_SPEC_CONST) \ - _(1353, ZEND_SEND_VAL_SPEC_TMPVAR) \ - _(1354, ZEND_SEND_VAL_SPEC_TMPVAR) \ - _(1361, ZEND_SEND_VAR_EX_SPEC_VAR) \ - _(1362, ZEND_SEND_VAR_EX_SPEC_VAR_QUICK) \ - _(1365, ZEND_SEND_VAR_EX_SPEC_CV) \ - _(1366, ZEND_SEND_VAR_EX_SPEC_CV_QUICK) \ - _(1369, ZEND_SEND_REF_SPEC_VAR) \ - _(1371, ZEND_SEND_REF_SPEC_CV) \ - _(1372, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1374, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1375, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1377, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1378, ZEND_FREE_SPEC_TMPVAR) \ - _(1379, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1380, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1381, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1382, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1383, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1384, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1385, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1386, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1387, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1388, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1389, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1390, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1391, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1392, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1393, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1394, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1395, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1396, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1397, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1398, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1399, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1400, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1401, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1402, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1403, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1404, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1405, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1406, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1407, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1408, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1409, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1410, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1411, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1412, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1413, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1414, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1415, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1416, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1417, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1418, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1424, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1425, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1426, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1427, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1428, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1429, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1430, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1431, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1433, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1434, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1435, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1436, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1438, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1449, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1450, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1451, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1453, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1459, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1460, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1461, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1463, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1474, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1475, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1476, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1478, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1479, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1480, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1481, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1483, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1484, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1485, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1486, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1488, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1489, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1490, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1491, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1493, ZEND_FE_RESET_R_SPEC_CV) \ - _(1494, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1495, ZEND_EXIT_SPEC) \ - _(1496, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1497, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1498, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1500, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1501, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1502, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1503, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1505, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1506, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1507, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1508, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1510, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1511, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1512, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1513, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1515, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1521, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1522, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1523, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1525, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1526, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1527, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1528, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1530, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1531, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1532, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1533, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1535, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1536, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1537, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1538, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1540, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1541, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1542, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1543, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1545, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1546, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1547, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1548, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1550, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1551, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1552, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1553, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1555, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1566, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1567, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1568, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1569, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1570, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1576, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1577, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1578, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1579, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1580, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1591, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1592, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1593, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1595, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1596, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1597, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1598, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1600, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1601, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1602, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1603, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1605, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1606, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1607, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1608, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1610, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1621, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1622, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1623, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1624, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1625, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1631, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1632, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1633, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1634, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1635, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1646, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1647, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1648, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1650, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1651, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1652, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1653, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1655, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1656, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1657, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1658, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1660, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1661, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1662, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1663, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1665, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1666, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1667, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1668, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1670, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1671, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1672, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1673, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1675, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1676, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1677, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1678, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1680, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1686, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1687, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1688, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1690, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1691, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1692, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1695, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1696, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1697, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1700, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1701, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1702, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1703, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1705, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1706, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1707, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1708, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1710, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1711, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1712, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1713, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1715, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1716, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1717, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1718, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1720, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1721, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1722, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1723, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1724, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1725, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1726, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1727, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1728, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1729, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1730, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1731, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1732, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1733, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1734, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1735, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1741, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1742, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1743, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1744, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1745, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1746, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1747, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1750, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1751, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1752, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1755, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1756, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1757, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1758, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1760, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1761, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1762, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1763, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1765, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1766, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1767, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1768, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1770, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1771, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1772, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1773, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1775, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1786, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1787, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1788, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1790, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1796, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1797, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1798, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1800, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1811, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1812, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1813, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1815, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1816, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1817, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1818, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1820, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1821, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1822, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1823, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1825, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1826, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1827, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1828, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1830, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1831, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1832, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1833, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1835, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1836, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1837, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1838, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1840, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1846, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1847, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1848, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1850, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1851, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1852, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED) \ - _(1853, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK) \ - _(1854, ZEND_EXT_STMT_SPEC) \ - _(1855, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1856, ZEND_EXT_FCALL_END_SPEC) \ - _(1857, ZEND_EXT_NOP_SPEC) \ - _(1858, ZEND_TICKS_SPEC) \ - _(1859, ZEND_SEND_VAR_NO_REF_SPEC_VAR) \ - _(1860, ZEND_CATCH_SPEC_CONST) \ - _(1861, ZEND_THROW_SPEC_CONST) \ - _(1862, ZEND_THROW_SPEC_TMPVAR) \ - _(1863, ZEND_THROW_SPEC_TMPVAR) \ - _(1865, ZEND_THROW_SPEC_CV) \ - _(1866, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1867, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1868, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1869, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1870, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1871, ZEND_CLONE_SPEC_CONST) \ - _(1872, ZEND_CLONE_SPEC_TMPVAR) \ - _(1873, ZEND_CLONE_SPEC_TMPVAR) \ - _(1874, ZEND_CLONE_SPEC_UNUSED) \ - _(1875, ZEND_CLONE_SPEC_CV) \ - _(1876, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1877, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1878, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1880, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1881, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1882, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1883, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1885, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1886, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1887, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1888, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1890, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(1891, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1892, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1893, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1895, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(1896, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(1897, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(1898, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(1900, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(1901, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(1902, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(1903, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(1905, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(1906, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(1907, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1908, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1909, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(1910, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(1916, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(1917, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(1918, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(1919, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(1920, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(1921, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(1922, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(1923, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(1924, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(1925, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(1931, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(1932, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(1933, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(1935, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(1936, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(1937, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(1938, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(1940, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(1941, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(1942, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(1943, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(1945, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(1946, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(1947, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(1948, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(1950, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(1956, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(1957, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(1958, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(1960, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(1961, ZEND_SEND_VAL_EX_SPEC_CONST) \ - _(1962, ZEND_SEND_VAL_EX_SPEC_CONST_QUICK) \ - _(1963, ZEND_SEND_VAL_EX_SPEC_TMP) \ - _(1964, ZEND_SEND_VAL_EX_SPEC_TMP_QUICK) \ - _(1973, ZEND_SEND_VAR_SPEC_VAR) \ - _(1975, ZEND_SEND_VAR_SPEC_CV) \ - _(1976, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(1977, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(1978, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(1980, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(1981, ZEND_SEND_ARRAY_SPEC) \ - _(1982, ZEND_SEND_USER_SPEC_CONST) \ - _(1983, ZEND_SEND_USER_SPEC_TMP) \ - _(1984, ZEND_SEND_USER_SPEC_VAR) \ - _(1986, ZEND_SEND_USER_SPEC_CV) \ - _(1987, ZEND_STRLEN_SPEC_CONST) \ - _(1988, ZEND_STRLEN_SPEC_TMPVAR) \ - _(1989, ZEND_STRLEN_SPEC_TMPVAR) \ - _(1991, ZEND_STRLEN_SPEC_CV) \ - _(1992, ZEND_DEFINED_SPEC_CONST) \ - _(1993, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(1994, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(1995, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(1997, ZEND_TYPE_CHECK_SPEC_CV) \ - _(1998, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(1999, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2000, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2001, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2002, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2003, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2004, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2005, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2007, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2008, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2009, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2010, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2011, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2012, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2014, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2015, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2016, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2017, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2018, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2019, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2020, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2031, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2032, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2033, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2035, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2036, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2037, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2038, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2040, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2041, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2042, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2043, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2045, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2056, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2057, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2058, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2060, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2061, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2062, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2063, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2065, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2066, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2067, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2068, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2070, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2071, ZEND_ECHO_SPEC_CONST) \ - _(2072, ZEND_ECHO_SPEC_TMPVAR) \ - _(2073, ZEND_ECHO_SPEC_TMPVAR) \ - _(2075, ZEND_ECHO_SPEC_CV) \ - _(2082, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2084, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2085, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2087, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2089, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2090, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2097, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2099, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2100, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2102, ZEND_GENERATOR_CREATE_SPEC) \ - _(2105, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2107, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2108, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2109, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2110, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2111, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2112, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2113, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2114, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2115, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2116, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2117, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2119, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2120, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2121, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2122, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2124, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2125, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2126, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2127, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2129, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2130, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2131, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2132, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2134, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2135, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2136, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2137, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2139, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2140, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2141, ZEND_USER_OPCODE_SPEC) \ - _(2142, ZEND_ASSERT_CHECK_SPEC) \ - _(2143, ZEND_JMP_SET_SPEC_CONST) \ - _(2144, ZEND_JMP_SET_SPEC_TMP) \ - _(2145, ZEND_JMP_SET_SPEC_VAR) \ - _(2147, ZEND_JMP_SET_SPEC_CV) \ - _(2148, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2149, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2150, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2151, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2152, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2153, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2155, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2156, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2158, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2159, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2160, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2161, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2162, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2163, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2164, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2165, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2166, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2167, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2168, ZEND_YIELD_SPEC_CONST_CV) \ - _(2169, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2170, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2171, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2172, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2173, ZEND_YIELD_SPEC_TMP_CV) \ - _(2174, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2175, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2176, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2177, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2178, ZEND_YIELD_SPEC_VAR_CV) \ - _(2179, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2180, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2181, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2182, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2183, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2184, ZEND_YIELD_SPEC_CV_CONST) \ - _(2185, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2186, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2187, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2188, ZEND_YIELD_SPEC_CV_CV) \ - _(2189, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2190, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2191, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2193, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2194, ZEND_FAST_CALL_SPEC) \ - _(2195, ZEND_FAST_RET_SPEC) \ - _(2196, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2197, ZEND_SEND_UNPACK_SPEC) \ - _(2198, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2199, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2200, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2202, ZEND_YIELD_FROM_SPEC_CV) \ - _(2203, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2204, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2205, ZEND_COALESCE_SPEC_CONST) \ - _(2206, ZEND_COALESCE_SPEC_TMP) \ - _(2207, ZEND_COALESCE_SPEC_VAR) \ - _(2209, ZEND_COALESCE_SPEC_CV) \ - _(2210, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2211, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2212, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2214, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2215, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2216, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2217, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2219, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2220, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2221, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2222, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2224, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2230, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2231, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2232, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2234, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2235, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2236, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2239, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2241, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2242, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2243, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2244, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2245, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2246, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2247, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2248, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2249, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2251, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2252, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2254, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2255, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2256, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2257, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ - _(2258, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2259, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2260, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2261, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2263, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2264, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2265, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2266, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2268, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2269, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2270, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2271, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2273, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2274, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2275, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2276, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2278, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2279, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2280, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2281, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2282, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2283, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2284, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2285, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2286, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2287, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2289, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2290, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2291, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2292, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2294, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2295, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2296, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2297, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2299, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2300, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2301, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2302, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2304, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2310, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2311, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2312, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2314, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2315, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2316, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2317, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2319, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2325, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2326, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2327, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2329, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2330, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2331, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2332, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2334, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2345, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2346, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2347, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2349, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2350, ZEND_JMP_NULL_SPEC_CONST) \ - _(2351, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2352, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2354, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2355, ZEND_RECV_NOTYPE_SPEC) \ - _(2356, ZEND_JMP_FORWARD_SPEC) \ - _(2362, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2363, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2364, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2366, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2367, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2368, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2369, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2371, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2377, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2378, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2379, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2381, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2387, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2388, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2389, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2391, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2392, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2393, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2394, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2396, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2402, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2403, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2404, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2406, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2412, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2413, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2414, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2416, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2417, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2418, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2419, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2421, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2427, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2428, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2429, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2431, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2433, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2434, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2436, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2437, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2438, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2439, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2441, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2442, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2443, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2444, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2446, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2452, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2453, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2454, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2456, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2458, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2459, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2461, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2462, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2463, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2464, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2466, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2467, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2468, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2469, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2471, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2477, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2478, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2479, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2481, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2483, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2484, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2486, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2487, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2488, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2489, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2491, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2492, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2493, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2494, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2496, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2502, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2503, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2504, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2506, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2512, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2513, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2514, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2516, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2517, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2518, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2519, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2521, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2527, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2528, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2529, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2531, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2537, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2538, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2539, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2541, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2542, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2543, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2544, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2546, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2552, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2554, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2562, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2563, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2564, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2566, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2567, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2569, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2577, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2578, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2611, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2612, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2613, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2617, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2618, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2620, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2624, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2625, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2626, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2642, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2644, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2645, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2647, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2648, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2650, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2654, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2655, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2656, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2672, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2686, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2687, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2688, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2692, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2693, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2695, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2699, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2700, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2701, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2717, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2719, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2720, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2722, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2723, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2725, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2729, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2730, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2731, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2747, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2761, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2762, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2767, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2768, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2770, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2774, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2776, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2792, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2793, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2794, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2795, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2797, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2798, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2799, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2800, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2804, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2806, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2822, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2836, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2837, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2838, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2841, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2843, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2844, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2849, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2850, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2851, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2867, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2868, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2869, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2870, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2873, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2880, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2881, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2886, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2887, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2891, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2895, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2896, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2897, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2898, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2899, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2900, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2904, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2905, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2906, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2908, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2919, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2920, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2921, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2922, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2923, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2925, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2926, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2927, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2928, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2929, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2930, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2934, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2935, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2936, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2952, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2953, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2954, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2955, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2956, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2957, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2958, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2959, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2960, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2964, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2965, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2966, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2971, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2972, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2973, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2981, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2983, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2994, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2995, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2996, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2997, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2998, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3000, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3001, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3002, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3003, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3004, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3005, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3009, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3010, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3011, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3027, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3028, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3029, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3030, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3031, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3032, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3033, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3034, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3035, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3039, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3040, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3041, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3046, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3047, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3048, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3056, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3058, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3070, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3073, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3075, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3076, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3077, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3084, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3085, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3086, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3103, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3104, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3105, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3106, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3107, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3108, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3109, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3110, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3114, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3115, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3116, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3131, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3132, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3133, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3148, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3177, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3178, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3179, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3183, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3185, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3190, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3191, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3192, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3193, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3194, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3195, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3196, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3197, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3198, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3199, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3200, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3201, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3202, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3203, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3204, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3205, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3206, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3208, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3209, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3210, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3211, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3213, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3214, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3215, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3216, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3218, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3220, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3221, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3223, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3224, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3225, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3226, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3228, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3229, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3230, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3231, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3233, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3239, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3240, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3241, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3243, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3246, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3248, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3251, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3253, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3254, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3255, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3256, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3257, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3257+1, ZEND_NULL) + _(1287, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1288, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1293, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED) \ + _(1294, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1297, ZEND_CAST_SPEC_CONST) \ + _(1298, ZEND_CAST_SPEC_TMP) \ + _(1299, ZEND_CAST_SPEC_VAR) \ + _(1301, ZEND_CAST_SPEC_CV) \ + _(1302, ZEND_BOOL_SPEC_CONST) \ + _(1303, ZEND_BOOL_SPEC_TMPVAR) \ + _(1304, ZEND_BOOL_SPEC_TMPVAR) \ + _(1306, ZEND_BOOL_SPEC_CV) \ + _(1307, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ + _(1308, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ + _(1309, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ + _(1311, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ + _(1312, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ + _(1313, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1314, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1316, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ + _(1317, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ + _(1318, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1319, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1321, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ + _(1327, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ + _(1328, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ + _(1329, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ + _(1331, ZEND_FAST_CONCAT_SPEC_CV_CV) \ + _(1332, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ + _(1333, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ + _(1334, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ + _(1336, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ + _(1337, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ + _(1338, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ + _(1339, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ + _(1341, ZEND_ROPE_ADD_SPEC_TMP_CV) \ + _(1342, ZEND_ROPE_END_SPEC_TMP_CONST) \ + _(1343, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ + _(1344, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ + _(1346, ZEND_ROPE_END_SPEC_TMP_CV) \ + _(1347, ZEND_BEGIN_SILENCE_SPEC) \ + _(1348, ZEND_END_SILENCE_SPEC_TMP) \ + _(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ + _(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ + _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ + _(1352, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1353, ZEND_RETURN_SPEC_CONST) \ + _(1354, ZEND_RETURN_SPEC_TMP) \ + _(1355, ZEND_RETURN_SPEC_VAR) \ + _(1357, ZEND_RETURN_SPEC_CV) \ + _(1358, ZEND_RECV_SPEC_UNUSED) \ + _(1359, ZEND_RECV_INIT_SPEC_CONST) \ + _(1360, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1363, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ + _(1365, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1368, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1370, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1373, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1405, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1406, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1411, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1412, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1425, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1426, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1431, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1432, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1445, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1448, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1455, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1458, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1460, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1462, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1463, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1465, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1466, ZEND_FREE_SPEC_TMPVAR) \ + _(1467, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1468, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1469, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1470, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1471, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1472, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1473, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1474, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1475, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1476, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1477, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1478, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1479, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1480, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1481, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1482, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1483, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1484, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1485, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1486, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1487, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1488, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1489, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1490, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1491, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1492, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1493, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1494, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1495, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1496, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1517, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ + _(1518, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1519, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1521, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1522, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1523, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1524, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1526, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1537, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1538, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1539, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1541, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1547, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1548, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1549, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1551, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1562, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1563, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1564, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1566, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1567, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1568, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1569, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1571, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1572, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1573, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1574, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1576, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1577, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1578, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1579, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1581, ZEND_FE_RESET_R_SPEC_CV) \ + _(1582, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1583, ZEND_EXIT_SPEC) \ + _(1584, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1585, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1586, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1588, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1589, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1590, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1591, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1593, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1594, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1595, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1596, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1598, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1599, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1609, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1610, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1613, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1614, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1615, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1616, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1618, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1619, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1620, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1621, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1623, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1624, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1633, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1639, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1640, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1641, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1643, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1654, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1655, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1656, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1657, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1658, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1664, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1665, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1666, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1667, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1668, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1679, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1680, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1681, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1683, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1684, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1685, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1686, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1688, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1689, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1694, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1695, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1696, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1698, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1709, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1710, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1711, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1712, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1713, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1719, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1720, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1721, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1722, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1723, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1734, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1735, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1736, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1738, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1739, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1740, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1741, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1743, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1744, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1749, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1750, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1751, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1753, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1754, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1755, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1756, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1758, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1759, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1760, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1761, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1763, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1764, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1774, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1775, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1778, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1779, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1780, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1781, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1783, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1784, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1785, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1786, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1788, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1789, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1798, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1804, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1805, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1806, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1808, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1809, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1810, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1811, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1812, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1813, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1814, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1834, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1835, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1836, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1838, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1839, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1859, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1860, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1861, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1863, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1874, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1875, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1876, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1878, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1884, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1885, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1886, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1888, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1899, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1900, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1901, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1903, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1904, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1914, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1915, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1916, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1918, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1919, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1920, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1921, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1923, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1924, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1939, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1940, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1941, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1950, ZEND_EXT_STMT_SPEC) \ + _(1951, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1952, ZEND_EXT_FCALL_END_SPEC) \ + _(1953, ZEND_EXT_NOP_SPEC) \ + _(1954, ZEND_TICKS_SPEC) \ + _(1955, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1958, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1960, ZEND_CATCH_SPEC_CONST) \ + _(1961, ZEND_THROW_SPEC_CONST) \ + _(1962, ZEND_THROW_SPEC_TMPVAR) \ + _(1963, ZEND_THROW_SPEC_TMPVAR) \ + _(1965, ZEND_THROW_SPEC_CV) \ + _(1966, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1967, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1968, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1969, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1970, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1971, ZEND_CLONE_SPEC_CONST) \ + _(1972, ZEND_CLONE_SPEC_TMPVAR) \ + _(1973, ZEND_CLONE_SPEC_TMPVAR) \ + _(1974, ZEND_CLONE_SPEC_UNUSED) \ + _(1975, ZEND_CLONE_SPEC_CV) \ + _(1976, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1977, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1978, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1980, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1981, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1982, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1983, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1985, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1986, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1987, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(1988, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(1990, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(1991, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1992, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(1993, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(1995, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(1996, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2005, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2006, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2007, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2008, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2009, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2010, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2016, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2031, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2032, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2033, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2035, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2036, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2037, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2038, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2040, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2041, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2042, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2043, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2045, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2046, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2061, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2062, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2067, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2068, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2071, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2072, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2077, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2121, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2124, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2131, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2134, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2136, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2137, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2138, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2140, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2141, ZEND_SEND_ARRAY_SPEC) \ + _(2142, ZEND_SEND_USER_SPEC_CONST) \ + _(2143, ZEND_SEND_USER_SPEC_TMP) \ + _(2144, ZEND_SEND_USER_SPEC_VAR) \ + _(2146, ZEND_SEND_USER_SPEC_CV) \ + _(2147, ZEND_STRLEN_SPEC_CONST) \ + _(2148, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2149, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2151, ZEND_STRLEN_SPEC_CV) \ + _(2152, ZEND_DEFINED_SPEC_CONST) \ + _(2153, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2154, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2155, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2157, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2158, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2159, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2160, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2161, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2162, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2163, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2164, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2165, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2167, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2168, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2169, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2170, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2171, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2172, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2174, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2175, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2176, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2177, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2178, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2179, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2180, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2191, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2192, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2193, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2195, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2196, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2197, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2198, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2200, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2201, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2202, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2203, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2205, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2216, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2217, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2218, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2220, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2221, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2222, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2223, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2225, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2226, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2227, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2228, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2230, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2231, ZEND_ECHO_SPEC_CONST) \ + _(2232, ZEND_ECHO_SPEC_TMPVAR) \ + _(2233, ZEND_ECHO_SPEC_TMPVAR) \ + _(2235, ZEND_ECHO_SPEC_CV) \ + _(2242, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2244, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2245, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2247, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2249, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2250, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2257, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2259, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2260, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2262, ZEND_GENERATOR_CREATE_SPEC) \ + _(2265, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2267, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2268, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2269, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2270, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2271, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2272, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2273, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2274, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2275, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2276, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2277, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2279, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2280, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2281, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2282, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2284, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2285, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2286, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2287, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2289, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2290, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2300, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2301, ZEND_USER_OPCODE_SPEC) \ + _(2302, ZEND_ASSERT_CHECK_SPEC) \ + _(2303, ZEND_JMP_SET_SPEC_CONST) \ + _(2304, ZEND_JMP_SET_SPEC_TMP) \ + _(2305, ZEND_JMP_SET_SPEC_VAR) \ + _(2307, ZEND_JMP_SET_SPEC_CV) \ + _(2308, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2309, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2310, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2311, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2312, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2313, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2315, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2316, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2318, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2319, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2320, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2321, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2322, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2323, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2324, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2325, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2326, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2327, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2328, ZEND_YIELD_SPEC_CONST_CV) \ + _(2329, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2330, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2331, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2332, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2333, ZEND_YIELD_SPEC_TMP_CV) \ + _(2334, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2335, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2336, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2337, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2338, ZEND_YIELD_SPEC_VAR_CV) \ + _(2339, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2340, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2341, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2342, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2343, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2344, ZEND_YIELD_SPEC_CV_CONST) \ + _(2345, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2346, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2347, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2348, ZEND_YIELD_SPEC_CV_CV) \ + _(2349, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2350, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2351, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2353, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2354, ZEND_FAST_CALL_SPEC) \ + _(2355, ZEND_FAST_RET_SPEC) \ + _(2356, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2357, ZEND_SEND_UNPACK_SPEC) \ + _(2358, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2359, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2360, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2362, ZEND_YIELD_FROM_SPEC_CV) \ + _(2363, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2364, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2365, ZEND_COALESCE_SPEC_CONST) \ + _(2366, ZEND_COALESCE_SPEC_TMP) \ + _(2367, ZEND_COALESCE_SPEC_VAR) \ + _(2369, ZEND_COALESCE_SPEC_CV) \ + _(2370, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2371, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2372, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2374, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2375, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2376, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2377, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2379, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2380, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2381, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2382, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2384, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2390, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2391, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2392, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2394, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2395, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2396, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2399, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2401, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2402, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2403, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2404, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2405, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2406, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2407, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2408, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2409, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2411, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2412, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2414, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2415, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2416, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2417, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2420, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2422, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2423, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2424, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2425, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2427, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2428, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2429, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2430, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2432, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2433, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2434, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2435, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2437, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2438, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2439, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2440, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2442, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2443, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2444, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2445, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2446, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2447, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2448, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2449, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2450, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2451, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2453, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2454, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2455, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2456, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2458, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2459, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2460, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2461, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2463, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2464, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2465, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2466, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2468, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2474, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2475, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2479, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2480, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2481, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2483, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2489, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2490, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2491, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2493, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2494, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2495, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2496, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2498, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2509, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2510, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2511, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2513, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2514, ZEND_JMP_NULL_SPEC_CONST) \ + _(2515, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2516, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2518, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2519, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2520, ZEND_RECV_NOTYPE_SPEC) \ + _(2521, ZEND_JMP_FORWARD_SPEC) \ + _(2527, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2531, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2532, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2533, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2534, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2536, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2552, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2553, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2554, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2556, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2558, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2561, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2577, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2579, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2581, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2582, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2598, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2599, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2601, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2602, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2623, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2624, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2627, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2628, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2629, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2631, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2649, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2651, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2652, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2653, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2677, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2678, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2702, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2703, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2728, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2731, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2763, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2764, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2765, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2776, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2837, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2838, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2839, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2840, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2841, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2851, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2912, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2913, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2914, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2915, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2916, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2926, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2987, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2988, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2989, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2990, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2991, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3001, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3051, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3052, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3056, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3060, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3061, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3063, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3064, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3071, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3073, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3074, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3075, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3076, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3086, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3136, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3137, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3148, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3211, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3212, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3222, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3223, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3357, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3358, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3359, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3360, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3361, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3362, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3363, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3364, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3365, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3366, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3367, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3368, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3369, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3370, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3371, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3373, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3374, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3375, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3376, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3378, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3379, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3380, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3381, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3383, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3385, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3386, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3388, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3389, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3394, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3395, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3396, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3398, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3411, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3413, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3416, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3418, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3419, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3420, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3421, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3422, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3422+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 296a952e12..56a31aa19a 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[199] = { +static const char *zend_vm_opcodes_names[200] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -222,9 +222,10 @@ static const char *zend_vm_opcodes_names[199] = { "ZEND_CASE_STRICT", "ZEND_MATCH_ERROR", "ZEND_JMP_NULL", + "ZEND_CHECK_UNDEF_ARGS", }; -static uint32_t zend_vm_opcodes_flags[199] = { +static uint32_t zend_vm_opcodes_flags[200] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -275,7 +276,7 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x00002007, 0x00000705, 0x00000101, - 0x00001001, + 0x00001301, 0x07000003, 0x00000007, 0x00000707, @@ -290,9 +291,9 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x00000003, 0x00040110, 0x00040310, - 0x00001007, - 0x00001001, - 0x00001001, + 0x00001307, + 0x00001301, + 0x00001301, 0x0100a173, 0x01040300, 0x00000005, @@ -325,13 +326,13 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x00040751, 0x0000070b, 0x00040391, - 0x00001001, + 0x00001301, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x01000000, - 0x00001001, + 0x00001301, 0x02042003, 0x00000007, 0x00040771, @@ -341,8 +342,8 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x01048773, 0x00030107, 0x00020707, - 0x00001003, - 0x00001001, + 0x00001303, + 0x00001301, 0x01000703, 0x01000000, 0x00001003, @@ -410,7 +411,7 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x00100101, 0x00100101, 0x00000101, - 0x00001001, + 0x00001301, 0x00000101, 0x0300030b, 0x0300030b, @@ -424,6 +425,7 @@ static uint32_t zend_vm_opcodes_flags[199] = { 0x00000301, 0x0000010b, 0x0000200b, + 0x00000101, }; 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 5b203f8d8c..df5a147999 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -275,7 +275,8 @@ END_EXTERN_C() #define ZEND_CASE_STRICT 196 #define ZEND_MATCH_ERROR 197 #define ZEND_JMP_NULL 198 +#define ZEND_CHECK_UNDEF_ARGS 199 -#define ZEND_VM_LAST_OPCODE 198 +#define ZEND_VM_LAST_OPCODE 199 #endif diff --git a/ext/curl/interface.c b/ext/curl/interface.c index e129c7708d..f8edbefa2f 100644 --- a/ext/curl/interface.c +++ b/ext/curl/interface.c @@ -1385,6 +1385,7 @@ static size_t curl_write(char *data, size_t size, size_t nmemb, void *ctx) fci.retval = &retval; fci.param_count = 2; fci.params = argv; + fci.named_params = NULL; ch->in_callback = 1; error = zend_call_function(&fci, &t->fci_cache); @@ -1431,6 +1432,7 @@ static int curl_fnmatch(void *ctx, const char *pattern, const char *string) fci.retval = &retval; fci.param_count = 3; fci.params = argv; + fci.named_params = NULL; ch->in_callback = 1; error = zend_call_function(&fci, &t->fci_cache); @@ -1483,6 +1485,7 @@ static size_t curl_progress(void *clientp, double dltotal, double dlnow, double fci.retval = &retval; fci.param_count = 5; fci.params = argv; + fci.named_params = NULL; ch->in_callback = 1; error = zend_call_function(&fci, &t->fci_cache); @@ -1538,6 +1541,7 @@ static size_t curl_read(char *data, size_t size, size_t nmemb, void *ctx) fci.retval = &retval; fci.param_count = 3; fci.params = argv; + fci.named_params = NULL; ch->in_callback = 1; error = zend_call_function(&fci, &t->fci_cache); @@ -1599,6 +1603,7 @@ static size_t curl_write_header(char *data, size_t size, size_t nmemb, void *ctx fci.retval = &retval; fci.param_count = 2; fci.params = argv; + fci.named_params = NULL; ch->in_callback = 1; error = zend_call_function(&fci, &t->fci_cache); diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c index c96f104229..06f52bb87f 100644 --- a/ext/dom/xpath.c +++ b/ext/dom/xpath.c @@ -150,6 +150,7 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, xmlXPathFreeObject(obj); fci.object = NULL; + fci.named_params = NULL; fci.retval = &retval; if (!zend_make_callable(&fci.function_name, &callable)) { diff --git a/ext/ffi/ffi.c b/ext/ffi/ffi.c index 6eac3a04a4..0be6ba4d4c 100644 --- a/ext/ffi/ffi.c +++ b/ext/ffi/ffi.c @@ -858,6 +858,7 @@ static void zend_ffi_callback_trampoline(ffi_cif* cif, void* ret, void** args, v fci.params = do_alloca(sizeof(zval) *callback_data->arg_count, use_heap); fci.object = NULL; fci.param_count = callback_data->arg_count; + fci.named_params = NULL; if (callback_data->type->func.args) { int n = 0; diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c index ba1fdf8033..505b4c05c6 100644 --- a/ext/mysqli/mysqli.c +++ b/ext/mysqli/mysqli.c @@ -1227,6 +1227,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags fci.retval = &retval; fci.params = NULL; fci.param_count = 0; + fci.named_params = NULL; if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) { if (zend_fcall_info_args(&fci, ctor_params) == FAILURE) { diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c index a8c770b3d0..3feba98d03 100644 --- a/ext/opcache/Optimizer/compact_literals.c +++ b/ext/opcache/Optimizer/compact_literals.c @@ -782,6 +782,20 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx opline->extended_value = cache_size; cache_size += sizeof(void *); break; + case ZEND_SEND_VAL: + case ZEND_SEND_VAL_EX: + case ZEND_SEND_VAR: + case ZEND_SEND_VAR_EX: + case ZEND_SEND_VAR_NO_REF: + case ZEND_SEND_VAR_NO_REF_EX: + case ZEND_SEND_REF: + case ZEND_SEND_FUNC_ARG: + case ZEND_CHECK_FUNC_ARG: + if (opline->op2_type == IS_CONST) { + opline->result.num = cache_size; + cache_size += 2 * sizeof(void *); + } + break; } opline++; } diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c index c1ac58d0de..b1d8f6b929 100644 --- a/ext/opcache/Optimizer/optimize_func_calls.c +++ b/ext/opcache/Optimizer/optimize_func_calls.c @@ -230,8 +230,8 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_FETCH_STATIC_PROP_FUNC_ARG: case ZEND_FETCH_OBJ_FUNC_ARG: case ZEND_FETCH_DIM_FUNC_ARG: - if (call_stack[call - 1].func) { - ZEND_ASSERT(call_stack[call - 1].func_arg_num != (uint32_t)-1); + if (call_stack[call - 1].func + && call_stack[call - 1].func_arg_num != (uint32_t)-1) { if (ARG_SHOULD_BE_SENT_BY_REF(call_stack[call - 1].func, call_stack[call - 1].func_arg_num)) { if (opline->opcode != ZEND_FETCH_STATIC_PROP_FUNC_ARG) { opline->opcode -= 9; @@ -257,6 +257,11 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; case ZEND_SEND_VAL_EX: if (call_stack[call - 1].func) { + if (opline->op2_type == IS_CONST) { + call_stack[call - 1].try_inline = 0; + break; + } + if (ARG_MUST_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { /* We won't convert it into_DO_FCALL to emit error at run-time */ call_stack[call - 1].opline = NULL; @@ -267,6 +272,12 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; case ZEND_CHECK_FUNC_ARG: if (call_stack[call - 1].func) { + if (opline->op2_type == IS_CONST) { + call_stack[call - 1].try_inline = 0; + call_stack[call - 1].func_arg_num = (uint32_t)-1; + break; + } + call_stack[call - 1].func_arg_num = opline->op2.num; MAKE_NOP(opline); } @@ -274,6 +285,11 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_SEND_VAR_EX: case ZEND_SEND_FUNC_ARG: if (call_stack[call - 1].func) { + if (opline->op2_type == IS_CONST) { + call_stack[call - 1].try_inline = 0; + break; + } + call_stack[call - 1].func_arg_num = (uint32_t)-1; if (ARG_SHOULD_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { opline->opcode = ZEND_SEND_REF; @@ -284,6 +300,11 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; case ZEND_SEND_VAR_NO_REF_EX: if (call_stack[call - 1].func) { + if (opline->op2_type == IS_CONST) { + call_stack[call - 1].try_inline = 0; + break; + } + if (ARG_MUST_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { opline->opcode = ZEND_SEND_VAR_NO_REF; } else if (ARG_MAY_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { @@ -293,6 +314,14 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) } } break; + case ZEND_SEND_VAL: + case ZEND_SEND_VAR: + case ZEND_SEND_REF: + if (opline->op2_type == IS_CONST) { + call_stack[call - 1].try_inline = 0; + break; + } + break; case ZEND_SEND_UNPACK: case ZEND_SEND_USER: case ZEND_SEND_ARRAY: diff --git a/ext/opcache/Optimizer/zend_call_graph.c b/ext/opcache/Optimizer/zend_call_graph.c index a32dacbb1b..0fa8945f09 100644 --- a/ext/opcache/Optimizer/zend_call_graph.c +++ b/ext/opcache/Optimizer/zend_call_graph.c @@ -124,8 +124,12 @@ int zend_analyze_calls(zend_arena **arena, zend_script *script, uint32_t build_f case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_USER: if (call_info) { - uint32_t num = opline->op2.num; + if (opline->op2_type == IS_CONST) { + call_info->named_args = 1; + break; + } + uint32_t num = opline->op2.num; if (num > 0) { num--; } diff --git a/ext/opcache/Optimizer/zend_call_graph.h b/ext/opcache/Optimizer/zend_call_graph.h index 1c263f6f63..28522a1277 100644 --- a/ext/opcache/Optimizer/zend_call_graph.h +++ b/ext/opcache/Optimizer/zend_call_graph.h @@ -36,6 +36,7 @@ struct _zend_call_info { zend_call_info *next_callee; zend_bool recursive; zend_bool send_unpack; /* Parameters passed by SEND_UNPACK or SEND_ARRAY */ + zend_bool named_args; /* Function has named arguments */ int num_args; zend_send_arg_info arg_info[1]; }; diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c index 1ca381d968..ab8b751acc 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -4354,13 +4354,8 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_JMP: case ZEND_CHECK_VAR: case ZEND_MAKE_REF: - case ZEND_SEND_VAR: case ZEND_BEGIN_SILENCE: case ZEND_END_SILENCE: - case ZEND_SEND_VAL: - case ZEND_SEND_REF: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_FUNC_ARG: case ZEND_FREE: case ZEND_SEPARATE: case ZEND_TYPE_CHECK: @@ -4375,10 +4370,17 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_FUNC_NUM_ARGS: case ZEND_FUNC_GET_ARGS: case ZEND_COPY_TMP: - case ZEND_CHECK_FUNC_ARG: case ZEND_CASE_STRICT: case ZEND_JMP_NULL: return 0; + case ZEND_SEND_VAR: + case ZEND_SEND_VAL: + case ZEND_SEND_REF: + case ZEND_SEND_VAR_EX: + case ZEND_SEND_FUNC_ARG: + case ZEND_CHECK_FUNC_ARG: + /* May throw for named params. */ + return opline->op2_type == IS_CONST; case ZEND_INIT_FCALL: /* can't throw, because call is resolved at compile time */ return 0; diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index 02329eb20e..feff3de6d3 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2521,6 +2521,10 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op goto done; case ZEND_SEND_VAL: case ZEND_SEND_VAL_EX: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT (yet) */ + break; + } if (opline->opcode == ZEND_SEND_VAL_EX && opline->op2.num > MAX_ARG_FLAG_NUM) { break; @@ -2531,6 +2535,10 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op } goto done; case ZEND_SEND_REF: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT (yet) */ + break; + } if (!zend_jit_send_ref(&dasm_state, opline, op_array, OP1_INFO(), 0)) { goto jit_failure; @@ -2541,6 +2549,10 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op case ZEND_SEND_VAR_NO_REF: case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_FUNC_ARG: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT (yet) */ + break; + } if ((opline->opcode == ZEND_SEND_VAR_EX || opline->opcode == ZEND_SEND_VAR_NO_REF_EX) && opline->op2.num > MAX_ARG_FLAG_NUM) { @@ -2560,6 +2572,10 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op } goto done; case ZEND_CHECK_FUNC_ARG: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT (yet) */ + break; + } if (opline->op2.num > MAX_ARG_FLAG_NUM) { break; } @@ -2567,6 +2583,11 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op goto jit_failure; } goto done; + case ZEND_CHECK_UNDEF_ARGS: + if (!zend_jit_check_undef_args(&dasm_state, opline)) { + goto jit_failure; + } + goto done; case ZEND_DO_UCALL: is_terminated = 1; /* break missing intentionally */ diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c index 39edc693c9..96fa37abb7 100644 --- a/ext/opcache/jit/zend_jit_trace.c +++ b/ext/opcache/jit/zend_jit_trace.c @@ -3538,6 +3538,10 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par goto done; case ZEND_SEND_VAL: case ZEND_SEND_VAL_EX: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT */ + break; + } if (opline->opcode == ZEND_SEND_VAL_EX && opline->op2.num > MAX_ARG_FLAG_NUM) { break; @@ -3562,6 +3566,10 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par } goto done; case ZEND_SEND_REF: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT */ + break; + } op1_info = OP1_INFO(); if (!zend_jit_send_ref(&dasm_state, opline, op_array, op1_info, 0)) { @@ -3573,6 +3581,10 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par case ZEND_SEND_VAR_NO_REF: case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_FUNC_ARG: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT */ + break; + } if ((opline->opcode == ZEND_SEND_VAR_EX || opline->opcode == ZEND_SEND_VAR_NO_REF_EX) && opline->op2.num > MAX_ARG_FLAG_NUM) { @@ -3609,6 +3621,10 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par } goto done; case ZEND_CHECK_FUNC_ARG: + if (opline->op2_type == IS_CONST) { + /* Named parameters not supported in JIT */ + break; + } if (opline->op2.num > MAX_ARG_FLAG_NUM && (!JIT_G(current_frame) || !JIT_G(current_frame)->call @@ -3619,6 +3635,11 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par goto jit_failure; } goto done; + case ZEND_CHECK_UNDEF_ARGS: + if (!zend_jit_check_undef_args(&dasm_state, opline)) { + goto jit_failure; + } + goto done; case ZEND_DO_UCALL: case ZEND_DO_ICALL: case ZEND_DO_FCALL_BY_NAME: diff --git a/ext/opcache/jit/zend_jit_vm_helpers.c b/ext/opcache/jit/zend_jit_vm_helpers.c index 26e9b6f843..f7704b72a4 100644 --- a/ext/opcache/jit/zend_jit_vm_helpers.c +++ b/ext/opcache/jit/zend_jit_vm_helpers.c @@ -57,6 +57,9 @@ ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_jit_leave_nested_func_helper(uint32_t } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } old_execute_data = execute_data; execute_data = EX(prev_execute_data); @@ -89,6 +92,9 @@ ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_jit_leave_top_func_helper(uint32_t ca } zend_vm_stack_free_extra_args_ex(call_info, execute_data); } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(EX(extra_named_params)); + } if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); } diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc index e5f7e6045a..561d6f937d 100644 --- a/ext/opcache/jit/zend_jit_x86.dasc +++ b/ext/opcache/jit/zend_jit_x86.dasc @@ -8567,7 +8567,8 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend #endif } - if ((opline-1)->opcode == ZEND_SEND_UNPACK|| (opline-1)->opcode == ZEND_SEND_ARRAY) { + if ((opline-1)->opcode == ZEND_SEND_UNPACK || (opline-1)->opcode == ZEND_SEND_ARRAY || + (opline-1)->opcode == ZEND_CHECK_UNDEF_ARGS) { unknown_num_args = 1; } @@ -8621,6 +8622,10 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend } } + bool may_have_extra_named_params = + opline->extended_value == ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS && + (!func || func->common.fn_flags & ZEND_ACC_VARIADIC); + if (!reuse_ip) { zend_jit_start_reuse_ip(); | // call = EX(call); @@ -9025,6 +9030,17 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend | mov FCARG1a, RX | EXT_CALL zend_jit_vm_stack_free_args_helper, r0 } + if (may_have_extra_named_params) { + | test byte [RX + offsetof(zend_execute_data, This.u1.type_info) + 3], (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS >> 24) + | jnz >1 + |.cold_code + |1: + | mov FCARG1a, aword [RX + offsetof(zend_execute_data, extra_named_params)] + | EXT_CALL zend_free_extra_named_params, r0 + | jmp >2 + |.code + |2: + } |8: if (opline->opcode == ZEND_DO_FCALL) { @@ -9183,6 +9199,24 @@ static int zend_jit_send_val(dasm_State **Dst, const zend_op *opline, const zend return 1; } +static int zend_jit_check_undef_args(dasm_State **Dst, const zend_op *opline) +{ + | mov FCARG1a, EX->call + | test byte [FCARG1a + offsetof(zend_execute_data, This.u1.type_info) + 3], (ZEND_CALL_MAY_HAVE_UNDEF >> 24) + | jnz >1 + |.cold_code + |1: + | SAVE_VALID_OPLINE opline, r0 + | EXT_CALL zend_handle_undef_args, r0 + | test r0, r0 + | jnz ->exception_handler + | jmp >2 + |.code + |2: + + return 1; +} + static int zend_jit_send_ref(dasm_State **Dst, const zend_op *opline, const zend_op_array *op_array, uint32_t op1_info, int cold) { zend_jit_addr op1_addr, arg_addr, ref_addr; @@ -10002,7 +10036,7 @@ static int zend_jit_leave_func(dasm_State **Dst, const zend_op *opline, const ze { /* ZEND_CALL_FAKE_CLOSURE handled on slow path to eliminate check for ZEND_CALL_CLOSURE on fast path */ | mov FCARG1d, dword [FP + offsetof(zend_execute_data, This.u1.type_info)] - | test FCARG1d, (ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_FAKE_CLOSURE) + | test FCARG1d, (ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_FAKE_CLOSURE) if (trace && trace->op != ZEND_JIT_TRACE_END) { | jnz >1 |.cold_code diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index 81034a38fe..9e9463c8fd 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -415,7 +415,8 @@ static void zend_file_cache_serialize_attribute(zval *zv, SERIALIZE_STR(attr->lcname); for (i = 0; i < attr->argc; i++) { - zend_file_cache_serialize_zval(&attr->argv[i], script, info, buf); + SERIALIZE_STR(attr->args[i].name); + zend_file_cache_serialize_zval(&attr->args[i].value, script, info, buf); } } @@ -1180,7 +1181,8 @@ static void zend_file_cache_unserialize_attribute(zval *zv, zend_persistent_scri UNSERIALIZE_STR(attr->lcname); for (i = 0; i < attr->argc; i++) { - zend_file_cache_unserialize_zval(&attr->argv[i], script, buf); + UNSERIALIZE_STR(attr->args[i].name); + zend_file_cache_unserialize_zval(&attr->args[i].value, script, buf); } } diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 1063106717..ed923a03cc 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -278,7 +278,10 @@ static HashTable *zend_persist_attributes(HashTable *attributes) zend_accel_store_interned_string(copy->lcname); for (i = 0; i < copy->argc; i++) { - zend_persist_zval(©->argv[i]); + if (copy->args[i].name) { + zend_accel_store_interned_string(copy->args[i].name); + } + zend_persist_zval(©->args[i].value); } ZVAL_PTR(v, copy); diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 7e43fc83c0..4a612751a6 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -165,7 +165,10 @@ static void zend_persist_attributes_calc(HashTable *attributes) ADD_INTERNED_STRING(attr->lcname); for (i = 0; i < attr->argc; i++) { - zend_persist_zval_calc(&attr->argv[i]); + if (attr->args[i].name) { + ADD_INTERNED_STRING(attr->args[i].name); + } + zend_persist_zval_calc(&attr->args[i].value); } } ZEND_HASH_FOREACH_END(); } diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c index 8138dd5e69..acaeb19dc6 100644 --- a/ext/pcre/php_pcre.c +++ b/ext/pcre/php_pcre.c @@ -2400,6 +2400,7 @@ PHP_FUNCTION(preg_replace_callback_array) fci.size = sizeof(fci); fci.object = NULL; + fci.named_params = NULL; ZEND_HASH_FOREACH_STR_KEY_VAL(pattern, str_idx_regex, replace) { if (!str_idx_regex) { diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c index 583374240c..f172d44ea9 100644 --- a/ext/pdo/pdo_dbh.c +++ b/ext/pdo/pdo_dbh.c @@ -437,6 +437,7 @@ static void pdo_stmt_construct(zend_execute_data *execute_data, pdo_stmt_t *stmt fci.retval = &retval; fci.param_count = 0; fci.params = NULL; + fci.named_params = NULL; zend_fcall_info_args(&fci, ctor_args); diff --git a/ext/pgsql/pgsql.c b/ext/pgsql/pgsql.c index c9b1652ea4..6ffe0efd84 100644 --- a/ext/pgsql/pgsql.c +++ b/ext/pgsql/pgsql.c @@ -2589,6 +2589,7 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, zend_long result_ fci.retval = &retval; fci.params = NULL; fci.param_count = 0; + fci.named_params = NULL; if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) { if (zend_fcall_info_args(&fci, ctor_params) == FAILURE) { diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index decb8d5e0a..48367c7deb 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -1796,18 +1796,19 @@ ZEND_METHOD(ReflectionFunctionAbstract, getStaticVariables) ZEND_METHOD(ReflectionFunction, invoke) { zval retval; - zval *params = NULL; - int result, num_args = 0; + zval *params; + int result, num_args; + HashTable *named_params; zend_fcall_info fci; zend_fcall_info_cache fcc; reflection_object *intern; zend_function *fptr; - GET_REFLECTION_OBJECT_PTR(fptr); + ZEND_PARSE_PARAMETERS_START(0, -1) + Z_PARAM_VARIADIC_WITH_NAMED(params, num_args, named_params) + ZEND_PARSE_PARAMETERS_END(); - if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) { - RETURN_THROWS(); - } + GET_REFLECTION_OBJECT_PTR(fptr); fci.size = sizeof(fci); ZVAL_UNDEF(&fci.function_name); @@ -1815,6 +1816,7 @@ ZEND_METHOD(ReflectionFunction, invoke) fci.retval = &retval; fci.param_count = num_args; fci.params = params; + fci.named_params = named_params; fcc.function_handler = fptr; fcc.called_scope = NULL; @@ -1846,36 +1848,26 @@ ZEND_METHOD(ReflectionFunction, invoke) ZEND_METHOD(ReflectionFunction, invokeArgs) { zval retval; - zval *params, *val; int result; - int i, argc; zend_fcall_info fci; zend_fcall_info_cache fcc; reflection_object *intern; zend_function *fptr; - zval *param_array; + HashTable *params; GET_REFLECTION_OBJECT_PTR(fptr); - if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", ¶m_array) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", ¶ms) == FAILURE) { RETURN_THROWS(); } - argc = zend_hash_num_elements(Z_ARRVAL_P(param_array)); - - params = safe_emalloc(sizeof(zval), argc, 0); - argc = 0; - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(param_array), val) { - ZVAL_COPY(¶ms[argc], val); - argc++; - } ZEND_HASH_FOREACH_END(); - fci.size = sizeof(fci); ZVAL_UNDEF(&fci.function_name); fci.object = NULL; fci.retval = &retval; - fci.param_count = argc; - fci.params = params; + fci.param_count = 0; + fci.params = NULL; + fci.named_params = params; fcc.function_handler = fptr; fcc.called_scope = NULL; @@ -1888,11 +1880,6 @@ ZEND_METHOD(ReflectionFunction, invokeArgs) result = zend_call_function(&fci, &fcc); - for (i = 0; i < argc; i++) { - zval_ptr_dtor(¶ms[i]); - } - efree(params); - if (result == FAILURE) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Invocation of function %s() failed", ZSTR_VAL(fptr->common.function_name)); @@ -3127,14 +3114,14 @@ ZEND_METHOD(ReflectionMethod, getClosure) static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) { zval retval; - zval *params = NULL, *val, *object; + zval *params = NULL, *object; + HashTable *named_params = NULL; reflection_object *intern; zend_function *mptr; - int i, argc = 0, result; + int argc = 0, result; zend_fcall_info fci; zend_fcall_info_cache fcc; zend_class_entry *obj_ce; - zval *param_array; GET_REFLECTION_OBJECT_PTR(mptr); @@ -3155,22 +3142,14 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) } if (variadic) { - if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!*", &object, ¶ms, &argc) == FAILURE) { - RETURN_THROWS(); - } + ZEND_PARSE_PARAMETERS_START(1, -1) + Z_PARAM_OBJECT_OR_NULL(object) + Z_PARAM_VARIADIC_WITH_NAMED(params, argc, named_params) + ZEND_PARSE_PARAMETERS_END(); } else { - if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!a", &object, ¶m_array) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!h", &object, &named_params) == FAILURE) { RETURN_THROWS(); } - - argc = zend_hash_num_elements(Z_ARRVAL_P(param_array)); - - params = safe_emalloc(sizeof(zval), argc, 0); - argc = 0; - ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(param_array), val) { - ZVAL_COPY(¶ms[argc], val); - argc++; - } ZEND_HASH_FOREACH_END(); } /* In case this is a static method, we shouldn't pass an object_ptr @@ -3207,6 +3186,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) fci.retval = &retval; fci.param_count = argc; fci.params = params; + fci.named_params = named_params; fcc.function_handler = mptr; fcc.called_scope = intern->ce; @@ -3221,13 +3201,6 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) result = zend_call_function(&fci, &fcc); - if (!variadic) { - for (i = 0; i < argc; i++) { - zval_ptr_dtor(¶ms[i]); - } - efree(params); - } - if (result == FAILURE) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Invocation of method %s::%s() failed", ZSTR_VAL(mptr->common.scope->name), ZSTR_VAL(mptr->common.function_name)); @@ -4676,8 +4649,9 @@ ZEND_METHOD(ReflectionClass, newInstance) /* Run the constructor if there is one */ if (constructor) { - zval *params = NULL; - int i, num_args = 0; + zval *params; + int num_args; + HashTable *named_params; if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->name)); @@ -4685,20 +4659,13 @@ ZEND_METHOD(ReflectionClass, newInstance) RETURN_NULL(); } - if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) { - zval_ptr_dtor(return_value); - RETURN_THROWS(); - } - - for (i = 0; i < num_args; i++) { - Z_TRY_ADDREF(params[i]); - } - - zend_call_known_instance_method(constructor, Z_OBJ_P(return_value), NULL, num_args, params); + ZEND_PARSE_PARAMETERS_START(0, -1) + Z_PARAM_VARIADIC_WITH_NAMED(params, num_args, named_params) + ZEND_PARSE_PARAMETERS_END(); - for (i = 0; i < num_args; i++) { - zval_ptr_dtor(¶ms[i]); - } + zend_call_known_function( + constructor, Z_OBJ_P(return_value), Z_OBJCE_P(return_value), NULL, + num_args, params, named_params); if (EG(exception)) { zend_object_store_ctor_failed(Z_OBJ_P(return_value)); @@ -4734,11 +4701,10 @@ ZEND_METHOD(ReflectionClass, newInstanceWithoutConstructor) /* {{{ Returns an instance of this class */ ZEND_METHOD(ReflectionClass, newInstanceArgs) { - zval *val; reflection_object *intern; zend_class_entry *ce, *old_scope; - int i, argc = 0; - HashTable *args; + int argc = 0; + HashTable *args = NULL; zend_function *constructor; GET_REFLECTION_OBJECT_PTR(ce); @@ -4747,8 +4713,8 @@ ZEND_METHOD(ReflectionClass, newInstanceArgs) RETURN_THROWS(); } - if (ZEND_NUM_ARGS() > 0) { - argc = args->nNumOfElements; + if (args) { + argc = zend_hash_num_elements(args); } if (UNEXPECTED(object_init_ex(return_value, ce) != SUCCESS)) { @@ -4762,31 +4728,14 @@ ZEND_METHOD(ReflectionClass, newInstanceArgs) /* Run the constructor if there is one */ if (constructor) { - zval *params = NULL; - if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->name)); zval_ptr_dtor(return_value); RETURN_NULL(); } - if (argc) { - params = safe_emalloc(sizeof(zval), argc, 0); - argc = 0; - ZEND_HASH_FOREACH_VAL(args, val) { - ZVAL_COPY(¶ms[argc], val); - argc++; - } ZEND_HASH_FOREACH_END(); - } - - zend_call_known_instance_method(constructor, Z_OBJ_P(return_value), NULL, argc, params); - - if (params) { - for (i = 0; i < argc; i++) { - zval_ptr_dtor(¶ms[i]); - } - efree(params); - } + zend_call_known_function( + constructor, Z_OBJ_P(return_value), Z_OBJCE_P(return_value), NULL, 0, NULL, args); if (EG(exception)) { zend_object_store_ctor_failed(Z_OBJ_P(return_value)); @@ -6273,12 +6222,17 @@ ZEND_METHOD(ReflectionAttribute, getArguments) RETURN_THROWS(); } - add_next_index_zval(return_value, &tmp); + if (attr->data->args[i].name) { + /* We ensured at compile-time that there are no duplicate parameter names. */ + zend_hash_add_new(Z_ARRVAL_P(return_value), attr->data->args[i].name, &tmp); + } else { + add_next_index_zval(return_value, &tmp); + } } } /* }}} */ -static int call_attribute_constructor(zend_class_entry *ce, zend_object *obj, zval *args, uint32_t argc) /* {{{ */ +static int call_attribute_constructor(zend_class_entry *ce, zend_object *obj, zval *args, uint32_t argc, HashTable *named_params) /* {{{ */ { zend_function *ctor = ce->constructor; ZEND_ASSERT(ctor != NULL); @@ -6288,7 +6242,8 @@ static int call_attribute_constructor(zend_class_entry *ce, zend_object *obj, zv return FAILURE; } - zend_call_known_instance_method(ctor, obj, NULL, argc, args); + zend_call_known_function(ctor, obj, obj->ce, NULL, argc, args, named_params); + if (EG(exception)) { zend_object_store_ctor_failed(obj); return FAILURE; @@ -6298,7 +6253,8 @@ static int call_attribute_constructor(zend_class_entry *ce, zend_object *obj, zv } /* }}} */ -static void attribute_ctor_cleanup(zval *obj, zval *args, uint32_t argc) /* {{{ */ +static void attribute_ctor_cleanup( + zval *obj, zval *args, uint32_t argc, HashTable *named_params) /* {{{ */ { if (obj) { zval_ptr_dtor(obj); @@ -6313,6 +6269,10 @@ static void attribute_ctor_cleanup(zval *obj, zval *args, uint32_t argc) /* {{{ efree(args); } + + if (named_params) { + zend_array_destroy(named_params); + } } /* }}} */ @@ -6327,8 +6287,7 @@ ZEND_METHOD(ReflectionAttribute, newInstance) zval obj; zval *args = NULL; - uint32_t count; - uint32_t argc = 0; + HashTable *named_params = NULL; if (zend_parse_parameters_none() == FAILURE) { RETURN_THROWS(); @@ -6385,31 +6344,40 @@ ZEND_METHOD(ReflectionAttribute, newInstance) RETURN_THROWS(); } - count = attr->data->argc; - - if (count) { - args = emalloc(count * sizeof(zval)); + uint32_t argc = 0; + if (attr->data->argc) { + args = emalloc(attr->data->argc * sizeof(zval)); - for (argc = 0; argc < attr->data->argc; argc++) { - if (FAILURE == zend_get_attribute_value(&args[argc], attr->data, argc, attr->scope)) { - attribute_ctor_cleanup(&obj, args, argc); + for (uint32_t i = 0; i < attr->data->argc; i++) { + zval val; + if (FAILURE == zend_get_attribute_value(&val, attr->data, i, attr->scope)) { + attribute_ctor_cleanup(&obj, args, i, named_params); RETURN_THROWS(); } + if (attr->data->args[i].name) { + if (!named_params) { + named_params = zend_new_array(0); + } + zend_hash_add_new(named_params, attr->data->args[i].name, &val); + } else { + ZVAL_COPY_VALUE(&args[i], &val); + argc++; + } } } if (ce->constructor) { - if (FAILURE == call_attribute_constructor(ce, Z_OBJ(obj), args, argc)) { - attribute_ctor_cleanup(&obj, args, argc); + if (FAILURE == call_attribute_constructor(ce, Z_OBJ(obj), args, argc, named_params)) { + attribute_ctor_cleanup(&obj, args, argc, named_params); RETURN_THROWS(); } - } else if (argc) { - attribute_ctor_cleanup(&obj, args, argc); + } else if (argc || named_params) { + attribute_ctor_cleanup(&obj, args, argc, named_params); zend_throw_error(NULL, "Attribute class %s does not have a constructor, cannot pass arguments", ZSTR_VAL(ce->name)); RETURN_THROWS(); } - attribute_ctor_cleanup(NULL, args, argc); + attribute_ctor_cleanup(NULL, args, argc, named_params); RETURN_COPY_VALUE(&obj); } diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c index 43effd0c99..d92f774db4 100644 --- a/ext/spl/php_spl.c +++ b/ext/spl/php_spl.c @@ -437,7 +437,7 @@ static zend_class_entry *spl_perform_autoload(zend_string *class_name, zend_stri zval param; ZVAL_STR(¶m, class_name); - zend_call_known_function(func, alfi->obj, alfi->ce, NULL, 1, ¶m); + zend_call_known_function(func, alfi->obj, alfi->ce, NULL, 1, ¶m, NULL); if (EG(exception)) { break; } diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index 45af9c270b..af337899f6 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -1904,6 +1904,7 @@ static int spl_filesystem_file_call(spl_filesystem_object *intern, zend_function fci.retval = return_value; fci.param_count = num_args; fci.params = params; + fci.named_params = NULL; ZVAL_STR(&fci.function_name, func_ptr->common.function_name); fcic.function_handler = func_ptr; diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index 6f2ce46c88..9b756d8694 100755 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -1549,7 +1549,7 @@ PHP_FUNCTION(call_user_func) ZEND_PARSE_PARAMETERS_START(1, -1) Z_PARAM_FUNC(fci, fci_cache) - Z_PARAM_VARIADIC('*', fci.params, fci.param_count) + Z_PARAM_VARIADIC_WITH_NAMED(fci.params, fci.param_count, fci.named_params) ZEND_PARSE_PARAMETERS_END(); fci.retval = &retval; @@ -1567,16 +1567,17 @@ PHP_FUNCTION(call_user_func) Warning: This function is special-cased by zend_compile.c and so is usually bypassed */ PHP_FUNCTION(call_user_func_array) { - zval *params, retval; + zval retval; + HashTable *params; zend_fcall_info fci; zend_fcall_info_cache fci_cache; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_FUNC(fci, fci_cache) - Z_PARAM_ARRAY(params) + Z_PARAM_ARRAY_HT(params) ZEND_PARSE_PARAMETERS_END(); - zend_fcall_info_args(&fci, params); + fci.named_params = params; fci.retval = &retval; if (zend_call_function(&fci, &fci_cache) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { @@ -1585,8 +1586,6 @@ PHP_FUNCTION(call_user_func_array) } ZVAL_COPY_VALUE(return_value, &retval); } - - zend_fcall_info_args_clear(&fci, 1); } /* }}} */ diff --git a/ext/xml/xml.c b/ext/xml/xml.c index 476d77444c..c5d3f71079 100644 --- a/ext/xml/xml.c +++ b/ext/xml/xml.c @@ -464,6 +464,7 @@ static void xml_call_handler(xml_parser *parser, zval *handler, zend_function *f fci.retval = retval; fci.param_count = argc; fci.params = argv; + fci.named_params = NULL; result = zend_call_function(&fci, NULL); if (result == FAILURE) { diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c index 0dc909d9d0..29b3ff5fb3 100644 --- a/ext/xsl/xsltprocessor.c +++ b/ext/xsl/xsltprocessor.c @@ -219,6 +219,7 @@ static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int t } fci.size = sizeof(fci); + fci.named_params = NULL; if (fci.param_count > 0) { fci.params = args; } else { |