]> granicus.if.org Git - php/commitdiff
Implement named parameters
authorNikita Popov <nikita.ppv@gmail.com>
Mon, 6 Apr 2020 10:46:52 +0000 (12:46 +0200)
committerNikita Popov <nikita.ppv@gmail.com>
Fri, 31 Jul 2020 13:53:36 +0000 (15:53 +0200)
From an engine perspective, named parameters mainly add three
concepts:

 * The SEND_* opcodes now accept a CONST op2, which is the
   argument name. For now, it is looked up by linear scan and
   runtime cached.
 * This may leave UNDEF arguments on the stack. To avoid having
   to deal with them in other places, a CHECK_UNDEF_ARGS opcode
   is used to either replace them with defaults, or error.
 * For variadic functions, EX(extra_named_params) are collected
   and need to be freed based on ZEND_CALL_HAS_EXTRA_NAMED_PARAMS.

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

Closes GH-5357.

79 files changed:
UPGRADING
Zend/tests/arg_unpack/non_integer_keys.phpt
Zend/tests/arg_unpack/string_keys.phpt
Zend/tests/assert/expect_015.phpt
Zend/tests/bug43343.phpt
Zend/tests/named_params/__call.phpt [new file with mode: 0644]
Zend/tests/named_params/__invoke.phpt [new file with mode: 0644]
Zend/tests/named_params/attributes.phpt [new file with mode: 0644]
Zend/tests/named_params/attributes_duplicate_named_param.phpt [new file with mode: 0644]
Zend/tests/named_params/attributes_named_flags.phpt [new file with mode: 0644]
Zend/tests/named_params/attributes_named_flags_incorrect.phpt [new file with mode: 0644]
Zend/tests/named_params/attributes_positional_after_named.phpt [new file with mode: 0644]
Zend/tests/named_params/backtrace.phpt [new file with mode: 0644]
Zend/tests/named_params/basic.phpt [new file with mode: 0644]
Zend/tests/named_params/call_user_func.phpt [new file with mode: 0644]
Zend/tests/named_params/call_user_func_array.phpt [new file with mode: 0644]
Zend/tests/named_params/defaults.phpt [new file with mode: 0644]
Zend/tests/named_params/duplicate_param.phpt [new file with mode: 0644]
Zend/tests/named_params/func_get_args.phpt [new file with mode: 0644]
Zend/tests/named_params/internal.phpt [new file with mode: 0644]
Zend/tests/named_params/internal_variadics.phpt [new file with mode: 0644]
Zend/tests/named_params/missing_param.phpt [new file with mode: 0644]
Zend/tests/named_params/positional_after_named.phpt [new file with mode: 0644]
Zend/tests/named_params/references.phpt [new file with mode: 0644]
Zend/tests/named_params/reserved.phpt [new file with mode: 0644]
Zend/tests/named_params/unknown_named_param.phpt [new file with mode: 0644]
Zend/tests/named_params/unpack.phpt [new file with mode: 0644]
Zend/tests/named_params/unpack_and_named_1.phpt [new file with mode: 0644]
Zend/tests/named_params/unpack_and_named_2.phpt [new file with mode: 0644]
Zend/tests/named_params/variadic.phpt [new file with mode: 0644]
Zend/zend_API.c
Zend/zend_API.h
Zend/zend_ast.c
Zend/zend_ast.h
Zend/zend_attributes.c
Zend/zend_attributes.h
Zend/zend_builtin_functions.c
Zend/zend_closures.c
Zend/zend_compile.c
Zend/zend_compile.h
Zend/zend_exceptions.c
Zend/zend_execute.c
Zend/zend_execute.h
Zend/zend_execute_API.c
Zend/zend_generators.c
Zend/zend_interfaces.c
Zend/zend_language_parser.y
Zend/zend_object_handlers.c
Zend/zend_vm_def.h
Zend/zend_vm_execute.h
Zend/zend_vm_gen.php
Zend/zend_vm_handlers.h
Zend/zend_vm_opcodes.c
Zend/zend_vm_opcodes.h
ext/curl/interface.c
ext/dom/xpath.c
ext/ffi/ffi.c
ext/mysqli/mysqli.c
ext/opcache/Optimizer/compact_literals.c
ext/opcache/Optimizer/optimize_func_calls.c
ext/opcache/Optimizer/zend_call_graph.c
ext/opcache/Optimizer/zend_call_graph.h
ext/opcache/Optimizer/zend_inference.c
ext/opcache/jit/zend_jit.c
ext/opcache/jit/zend_jit_trace.c
ext/opcache/jit/zend_jit_vm_helpers.c
ext/opcache/jit/zend_jit_x86.dasc
ext/opcache/zend_file_cache.c
ext/opcache/zend_persist.c
ext/opcache/zend_persist_calc.c
ext/pcre/php_pcre.c
ext/pdo/pdo_dbh.c
ext/pgsql/pgsql.c
ext/reflection/php_reflection.c
ext/spl/php_spl.c
ext/spl/spl_directory.c
ext/standard/basic_functions.c
ext/xml/xml.c
ext/xsl/xsltprocessor.c

index 46b6d328c8cb6d288b0a3f763ba47a48af5accb9..a71c8959c362e31673d901c3b5ac76029214e768 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -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
index 6b73efa416dd3d2bcc03f11bafa4e5bd95cfe285..88e1747df9c33fca8aab20857741fa5f2841f42c 100644 (file)
@@ -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
index 7b620b08304bd6e777ad75bffe34f38d92e0dcee..b0bf366fb38dcb408a20e66ecd21e0f753e934d4 100644 (file)
@@ -7,11 +7,6 @@ set_error_handler(function($errno, $errstr) {
     var_dump($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) {
@@ -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"
index ac67780730c524dec2f7231ca611787597b51364..ed1b442d6e9180ea69b5fe68dd87e5c02ee33151 100644 (file)
@@ -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);
         }
 
     }
index c277ccccddcdb3b33d449222d3be6beeb8bed95c..748562e985ae0cb6b68f2b2337178025d07cdbb3 100644 (file)
@@ -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 (file)
index 0000000..a5ebdc2
--- /dev/null
@@ -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 (file)
index 0000000..6ebbac0
--- /dev/null
@@ -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 (file)
index 0000000..931dbfb
--- /dev/null
@@ -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 (file)
index 0000000..bcd9f9b
--- /dev/null
@@ -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 (file)
index 0000000..f553aa5
--- /dev/null
@@ -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 (file)
index 0000000..6f5b226
--- /dev/null
@@ -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 (file)
index 0000000..61cee4d
--- /dev/null
@@ -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 (file)
index 0000000..1ccae85
--- /dev/null
@@ -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 (file)
index 0000000..4ad187d
--- /dev/null
@@ -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 (file)
index 0000000..5a11dfd
--- /dev/null
@@ -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 (file)
index 0000000..ebee06e
--- /dev/null
@@ -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 (file)
index 0000000..23f2cab
--- /dev/null
@@ -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 (file)
index 0000000..6abc95b
--- /dev/null
@@ -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 (file)
index 0000000..a33f452
--- /dev/null
@@ -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 (file)
index 0000000..97260c2
--- /dev/null
@@ -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 (file)
index 0000000..3599f64
--- /dev/null
@@ -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 (file)
index 0000000..52dc1b1
--- /dev/null
@@ -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 (file)
index 0000000..a415df5
--- /dev/null
@@ -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 (file)
index 0000000..aa3689b
--- /dev/null
@@ -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 (file)
index 0000000..93ae470
--- /dev/null
@@ -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 (file)
index 0000000..f43a40c
--- /dev/null
@@ -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 (file)
index 0000000..92bb479
--- /dev/null
@@ -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 (file)
index 0000000..24d448d
--- /dev/null
@@ -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 (file)
index 0000000..2035b2e
--- /dev/null
@@ -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 (file)
index 0000000..212a456
--- /dev/null
@@ -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)
index c6e4b03dfcf28fad343767f3fef3ffecf51b7a5a..62387d1be5d41d37206cdc29d19e45c55b8fd6cd 100644 (file)
@@ -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 = &reg_function->common.arg_info[i];
+                               zend_internal_arg_info *arg_info = &reg_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;
 }
index 7733d18584fa3a352993c6b71bcce9de871aa68e..916a2ab425688c129d7b7b8acbe7a06cb02dacca 100644 (file)
@@ -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))) { \
index 1affe08c37fe5e0638fc082636ef32e3eeb91d2b..e2a2aca698d4841222d6496efaee55b4379f8f0d 100644 (file)
@@ -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:
index 79af596f24c1f38fcbb3fa3537c46f8c9827b812..97236c5560c071f4fe20d9b13f6b138322e65b09 100644 (file)
@@ -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,
index c58ff95fb6ea22c7cef84cef6ad50a18b8ee6c1c..e55f27f84a8894c58fca4c52d6a15d93f6de78aa 100644 (file)
@@ -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);
index 16221fa5426441658f67f2c1389e2a9da09bdae0..6b7150a363dd9bc861fcfc77b5c8ae514f41da87 100644 (file)
 #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 {
index 1de771660aae932d13967f466586c65f16f222b3..588c3c33d7f717141ab33b065766151b3d9468fb 100644 (file)
@@ -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();
 }
index e2395473361492ccc2b35524d7fe01fad6478832..68ae1e47b0bf49220cbb14340c95f23c3be61a21 100644 (file)
@@ -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);
index 790b2acc896122726959445a853357b28d0b6d10..78b72de1a7e07b37ca85c522ad065b5121f170aa 100644 (file)
@@ -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);
                        }
                }
        }
index d804b998dedd13befce2b22ac10225ed77b2baea..df3171f76d1ef6a078be782f51fb8c32f49d0c61 100644 (file)
@@ -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))
index 8c96bb60981a30d5f696621840f5fcc692795094..85ca5f74b35c8d010c0b673c825f4c74c138169f 100644 (file)
@@ -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);
 
index d6809cb67011ce799de4a96efa325f170d5077ed..b89809c88a807dc66bbd0748cd04154c7cdf6d4b 100644 (file)
@@ -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) /* {{{ */
index 827b735c705e2de6d21efa70252a25952adf1832..f93a9f5e0e86af1565bdf4756a4a6124004ad14c 100644 (file)
@@ -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)))
 
index e6f1e44fca1ac183e97c89e6a29722ce4b1cfafb..b3d6319560dc25440dcb6b2cd9696bbf7598b7c8 100644 (file)
@@ -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;
index 21a44b386517306eb13f2b4faea80cbca736661b..0d2d7e4a4d9563ffdbe8da53ee0c26cc82e2c8f2 100644 (file)
@@ -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;
index 37c72ef5547c6d9a3e7b527c5cf7340b2400acb7..16c193e42060e103a977d5b1457d437b3e9aa1d1 100644 (file)
@@ -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;
 }
 /* }}} */
index 55f2c0f49cf182092631b47c93fa743b56a7fce0..1a566e352d2d9f47a0e24e9a486c25fcd2c325a1 100644 (file)
@@ -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); }
 ;
 
index ebec6921cb9db24b5ab58d5175c0ab4737fafe8b..b3eb2d1ba597b770c6a73489ea9a7380ed7b0dab 100644 (file)
@@ -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;
 }
index a9b5c0f4a3c4295ab067d2da97876de083b83a0b..86a86bd6527e9996f5f50264a213e6c56359c2b0 100644 (file)
@@ -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;
index 3e6edeb8df597b8b664eccb62eda4ccd0d6239f6..4f118764a8eb2861648349cee1c2548b342055d4 100644 (file)
@@ -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_SEND_VAR_EX_SPEC_VAR_LABEL,
-                       (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_LABEL,
                        (void*)&&ZEND_NULL_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_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_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_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_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,21 +51945,81 @@ 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_SEND_VAR_SPEC_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SEND_VAR_SPEC_CV_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,
+                       (void*)&&ZEND_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_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_SEND_VAR_EX_SPEC_VAR_HANDLER,
-               ZEND_SEND_VAR_EX_SPEC_VAR_QUICK_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_SEND_VAR_EX_SPEC_CV_HANDLER,
-               ZEND_SEND_VAR_EX_SPEC_CV_QUICK_HANDLER,
                ZEND_NULL_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_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_NULL_HANDLER,
+               ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_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,39 @@ 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,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -58461,9 +59858,40 @@ 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_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:
index ae1da5d2e88c8d06ffb04f9478ca1dc52dd33131..aa70a6311373ea14c10feff2496188669097bf1f 100755 (executable)
@@ -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) {
index e4eb0205391e45e5f495a2a14c7a1f2bbf585d2d..afcc07a8fdc35725023efb895c70300a9a551820 100644 (file)
        _(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)
index 296a952e127fae7a0887b3ec998f44bcb77f870e..56a31aa19a09532649942e4f7fd5b27abd521180 100644 (file)
@@ -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) {
index 5b203f8d8ca63d745d882e7ec8de5d12a763844a..df5a14799953a36a0a2f5d943a4b239a38762299 100644 (file)
@@ -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
index e129c7708d4bf951e390e91d468069badc3d640a..f8edbefa2f15d014c9d38320d7274e1353e9e72e 100644 (file)
@@ -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);
index c96f10422943c2a5129d1a06e4aa6683bd260197..06f52bb87fbd6cb5e97bc048be0177100a26df20 100644 (file)
@@ -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)) {
index 6eac3a04a4632bc918bf79d577448f0545203564..0be6ba4d4c9be452ac7339650f9f20b238437d5a 100644 (file)
@@ -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;
index ba1fdf8033ce5134a751aefd8e143fe8666e870b..505b4c05c668d0057cdfc2f1cda0640ffb52caae 100644 (file)
@@ -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) {
index a8c770b3d0d9976083c72952d9c74e2f32a2caca..3feba98d033c6f368441a1d0b53d485a190ad85b 100644 (file)
@@ -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++;
                }
index c1ac58d0de7de12e30d2cc50d7877876146928da..b1d8f6b929b782492b0b09c9c270fdc8fff0da18 100644 (file)
@@ -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:
index a32dacbb1bf7e580fd5be3c11defa662a3f3c3c3..0fa8945f092cae8cb6581096b8b2a3a768dd7c50 100644 (file)
@@ -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--;
                                        }
index 1c263f6f6398bb1c08985e10bed5f0b77d8f1784..28522a12779b57901252a916a27759ebdfcdb2f5 100644 (file)
@@ -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];
 };
index 1ca381d9686645fb4614643158b1535051756c06..ab8b751acc461af189c3e59e2c324d489ca377b3 100644 (file)
@@ -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;
index 02329eb20e66c6dbe2ddfe0b118c87ac8f07b719..feff3de6d323bddef0ce13aa7e04e1403058aab3 100644 (file)
@@ -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 */
index 39edc693c96bfe3cee1d94454c92ddf5faad75ab..96fa37abb79a56f2082bdacf0fa380ae5522cdd2 100644 (file)
@@ -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:
index 26e9b6f843b772e2d00ce44e31627cb0a288632c..f7704b72a40ffd0bb6a8942cf27353e92dadd6ab 100644 (file)
@@ -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)));
        }
index e5f7e6045a801dd0dd681a03175d7e482c2e4e5e..561d6f937d13819ea143643faf9c99ffe24ce817 100644 (file)
@@ -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
index 81034a38fe9ca60394ea4c56d215cb6a7539f206..9e9463c8fd0864fe2e650d49433f4b32a06bdf8d 100644 (file)
@@ -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);
        }
 }
 
index 10631067171298192bf2dc7aabee5e100a1329c5..ed923a03cc9de1b0b134eb3a684043b41ff95947 100644 (file)
@@ -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(&copy->argv[i]);
+                               if (copy->args[i].name) {
+                                       zend_accel_store_interned_string(copy->args[i].name);
+                               }
+                               zend_persist_zval(&copy->args[i].value);
                        }
 
                        ZVAL_PTR(v, copy);
index 7e43fc83c0c0a584e5d3f96cf396375d09cfca3f..4a612751a6c2818611d7c3275c3571e6582ee989 100644 (file)
@@ -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();
        }
index 8138dd5e699962424ed55f55a19ad648d699c712..acaeb19dc68ca054fb0646b4ef5b0c8e74a95b21 100644 (file)
@@ -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) {
index 583374240c7a3cdac0150eb6be1b262c4f0f1ed9..f172d44ea93793315639ed69a03ad66e178a13da 100644 (file)
@@ -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);
 
index c9b1652ea4fc33d1ede1bfe5e5ec71b64035c4d4..6ffe0efd847d5af43644dabcec0da6a82e15917a 100644 (file)
@@ -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) {
index decb8d5e0a0923d3ed3c671c764f980aadfdf019..48367c7debb6f3116b977d6a20dece3a32ae7be3 100644 (file)
@@ -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(), "*", &params, &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", &param_array) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &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(&params[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(&params[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, &params, &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, &param_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(&params[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(&params[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(), "*", &params, &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(&params[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(&params[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(&params[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);
 }
index 43effd0c9908bace3a9e21e484fd03e519b9303b..d92f774db46328f7541396461e0f9b819571b452 100644 (file)
@@ -437,7 +437,7 @@ static zend_class_entry *spl_perform_autoload(zend_string *class_name, zend_stri
 
                zval param;
                ZVAL_STR(&param, class_name);
-               zend_call_known_function(func, alfi->obj, alfi->ce, NULL, 1, &param);
+               zend_call_known_function(func, alfi->obj, alfi->ce, NULL, 1, &param, NULL);
                if (EG(exception)) {
                        break;
                }
index 45af9c270b1885ba1ad0fcd9659b3562f9cad1cc..af337899f6206da62105f26c868cb3795674c1c8 100644 (file)
@@ -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;
index 6f2ce46c880923daf10840a67ad727b79e196c12..9b756d8694236ea6fac37b5bd65e0ddc04ce4a62 100755 (executable)
@@ -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);
 }
 /* }}} */
 
index 476d77444c698ea0901d4d175fc775f8d529c5ad..c5d3f71079fa2377fe6245f4dac69188662e0c69 100644 (file)
@@ -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) {
index 0dc909d9d087d0623cbc0864262590cf63614d44..29b3ff5fb34e2287f9f649009b1a08943d4c8002 100644 (file)
@@ -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 {