Implement spread operator in arrays

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

Closes GH-3640.

diff --git a/UPGRADING b/UPGRADING
index de5f1dd5a19aa3687d743eaabccb83b9d160d680..b7f4c6cface681d5bf256fcfb5a2f5f6c77f948d 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -166,6 +166,14 @@ PHP 7.4 UPGRADE NOTES
 
     RFC: https://wiki.php.net/rfc/null_coalesce_equal_operator
 
+  . Added support for unpacking inside arrays. For example:
+
+        $arr1 = [3, 4];
+        $arr2 = [1, 2, ...$arr1, 5];
+        // $arr2 == [1, 2, 3, 4, 5]
+
+    RFC: https://wiki.php.net/rfc/spread_operator_for_array
+
   . Support for WeakReferences has been added.
     RFC: https://wiki.php.net/rfc/weakrefs
 

diff --git a/Zend/tests/array_unpack/already_occupied.phpt b/Zend/tests/array_unpack/already_occupied.phpt
new file mode 100644 (file)
index 0000000..27a18b6
--- /dev/null
+++ b/Zend/tests/array_unpack/already_occupied.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Appending to an array via unpack may fail
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die("skip 64bit only"); ?>
+--FILE--
+<?php
+
+$arr = [1, 2, 3];
+var_dump([PHP_INT_MAX-1 => 0, ...$arr]);
+
+var_dump([PHP_INT_MAX-1 => 0, ...[1, 2, 3]]);
+
+const ARR = [1, 2, 3];
+const ARR2 = [PHP_INT_MAX-1 => 0, ...ARR];
+var_dump(ARR2);
+
+?>
+--EXPECTF--
+Warning: Cannot add element to the array as the next element is already occupied in %s on line %d
+array(2) {
+  [9223372036854775806]=>
+  int(0)
+  [9223372036854775807]=>
+  int(1)
+}
+
+Warning: Cannot add element to the array as the next element is already occupied in %s on line %d
+array(2) {
+  [9223372036854775806]=>
+  int(0)
+  [9223372036854775807]=>
+  int(1)
+}
+
+Warning: Cannot add element to the array as the next element is already occupied in %s on line %d
+array(2) {
+  [9223372036854775806]=>
+  int(0)
+  [9223372036854775807]=>
+  int(1)
+}

diff --git a/Zend/tests/array_unpack/basic.phpt b/Zend/tests/array_unpack/basic.phpt
new file mode 100644 (file)
index 0000000..0e10638
--- /dev/null
+++ b/Zend/tests/array_unpack/basic.phpt
@@ -0,0 +1,119 @@
+--TEST--\r
+Basic array unpacking\r
+--FILE--\r
+<?php\r
+$array = [1, 2, 3];\r
+\r
+function getArr() {\r
+       return [4, 5];\r
+}\r
+\r
+function arrGen() {\r
+       for($i = 11; $i < 15; $i++) {\r
+               yield $i;\r
+       }\r
+}\r
+\r
+var_dump([...[]]);\r
+var_dump([...[1, 2, 3]]);\r
+var_dump([...$array]);\r
+var_dump([...getArr()]);\r
+var_dump([...arrGen()]);\r
+var_dump([...new ArrayIterator(['a', 'b', 'c'])]);\r
+\r
+var_dump([0, ...$array, ...getArr(), 6, 7, 8, 9, 10, ...arrGen()]);\r
+var_dump([0, ...$array, ...$array, 'end']);\r
+\r
+--EXPECT--\r
+array(0) {\r
+}\r
+array(3) {\r
+  [0]=>\r
+  int(1)\r
+  [1]=>\r
+  int(2)\r
+  [2]=>\r
+  int(3)\r
+}\r
+array(3) {\r
+  [0]=>\r
+  int(1)\r
+  [1]=>\r
+  int(2)\r
+  [2]=>\r
+  int(3)\r
+}\r
+array(2) {\r
+  [0]=>\r
+  int(4)\r
+  [1]=>\r
+  int(5)\r
+}\r
+array(4) {\r
+  [0]=>\r
+  int(11)\r
+  [1]=>\r
+  int(12)\r
+  [2]=>\r
+  int(13)\r
+  [3]=>\r
+  int(14)\r
+}\r
+array(3) {\r
+  [0]=>\r
+  string(1) "a"\r
+  [1]=>\r
+  string(1) "b"\r
+  [2]=>\r
+  string(1) "c"\r
+}\r
+array(15) {\r
+  [0]=>\r
+  int(0)\r
+  [1]=>\r
+  int(1)\r
+  [2]=>\r
+  int(2)\r
+  [3]=>\r
+  int(3)\r
+  [4]=>\r
+  int(4)\r
+  [5]=>\r
+  int(5)\r
+  [6]=>\r
+  int(6)\r
+  [7]=>\r
+  int(7)\r
+  [8]=>\r
+  int(8)\r
+  [9]=>\r
+  int(9)\r
+  [10]=>\r
+  int(10)\r
+  [11]=>\r
+  int(11)\r
+  [12]=>\r
+  int(12)\r
+  [13]=>\r
+  int(13)\r
+  [14]=>\r
+  int(14)\r
+}\r
+array(8) {\r
+  [0]=>\r
+  int(0)\r
+  [1]=>\r
+  int(1)\r
+  [2]=>\r
+  int(2)\r
+  [3]=>\r
+  int(3)\r
+  [4]=>\r
+  int(1)\r
+  [5]=>\r
+  int(2)\r
+  [6]=>\r
+  int(3)\r
+  [7]=>\r
+  string(3) "end"\r
+}\r

diff --git a/Zend/tests/array_unpack/classes.phpt b/Zend/tests/array_unpack/classes.phpt
new file mode 100644 (file)
index 0000000..349c5d9
--- /dev/null
+++ b/Zend/tests/array_unpack/classes.phpt
@@ -0,0 +1,46 @@
+--TEST--\r
+Array unpacking with classes\r
+--FILE--\r
+<?php\r
+\r
+class C {\r
+       public const FOO = [0, ...self::ARR, 4];\r
+       public const ARR = [1, 2, 3];\r
+       public static $bar = [...self::ARR];\r
+}\r
+\r
+class D {\r
+       public const A = [...self::B];\r
+       public const B = [...self::A];\r
+}\r
+\r
+var_dump(C::FOO);\r
+var_dump(C::$bar);\r
+\r
+try {\r
+       var_dump(D::A);\r
+} catch (Error $ex) {\r
+       echo "Exception: " . $ex->getMessage() . "\n";\r
+}\r
+--EXPECT--\r
+array(5) {\r
+  [0]=>\r
+  int(0)\r
+  [1]=>\r
+  int(1)\r
+  [2]=>\r
+  int(2)\r
+  [3]=>\r
+  int(3)\r
+  [4]=>\r
+  int(4)\r
+}\r
+array(3) {\r
+  [0]=>\r
+  int(1)\r
+  [1]=>\r
+  int(2)\r
+  [2]=>\r
+  int(3)\r
+}\r
+Exception: Cannot declare self-referencing constant 'self::B'
\ No newline at end of file

diff --git a/Zend/tests/array_unpack/in_destructuring.phpt b/Zend/tests/array_unpack/in_destructuring.phpt
new file mode 100644 (file)
index 0000000..fed2826
--- /dev/null
+++ b/Zend/tests/array_unpack/in_destructuring.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Spread operator is not supported in destructuring assignments
+--FILE--
+<?php
+
+[$head, ...$tail] = [1, 2, 3];
+
+?>
+--EXPECTF--
+Fatal error: Spread operator is not supported in assignments in %s on line %d

diff --git a/Zend/tests/array_unpack/non_integer_keys.phpt b/Zend/tests/array_unpack/non_integer_keys.phpt
new file mode 100644 (file)
index 0000000..5c93102
--- /dev/null
+++ b/Zend/tests/array_unpack/non_integer_keys.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Array unpacking does not work with non-integer keys
+--FILE--
+<?php
+function gen() {
+       yield [] => 1;
+       yield 1.23 => 123;
+}
+
+try {
+       [...gen()];
+} catch (Error $ex) {
+       echo "Exception: " . $ex->getMessage() . "\n";
+}
+
+--EXPECT--
+Exception: Cannot unpack Traversable with non-integer keys

diff --git a/Zend/tests/array_unpack/ref1.phpt b/Zend/tests/array_unpack/ref1.phpt
new file mode 100644 (file)
index 0000000..10b33b8
--- /dev/null
+++ b/Zend/tests/array_unpack/ref1.phpt
@@ -0,0 +1,17 @@
+--TEST--\r
+Array unpacking with element rc=1\r
+--FILE--\r
+<?php\r
+\r
+$a = 1;\r
+$b = [&$a]; //array (0 => (refcount=2, is_ref=1)=1)\r
+\r
+unset($a); //array (0 => (refcount=1, is_ref=1)=1)\r
+\r
+var_dump([...$b]); //array (0 => (refcount=0, is_ref=0)=1)\r
+\r
+--EXPECT--\r
+array(1) {\r
+  [0]=>\r
+  int(1)\r
+}\r

diff --git a/Zend/tests/array_unpack/string_keys.phpt b/Zend/tests/array_unpack/string_keys.phpt
new file mode 100644 (file)
index 0000000..6032d7c
--- /dev/null
+++ b/Zend/tests/array_unpack/string_keys.phpt
@@ -0,0 +1,21 @@
+--TEST--
+array unpacking with string keys (not supported)
+--FILE--
+<?php
+
+try {
+       $array = [1, 2, "foo" => 3, 4];
+       var_dump([...$array]);
+} catch (Error $ex) {
+       var_dump($ex->getMessage());
+}
+try {
+       $iterator = new ArrayIterator([1, 2, "foo" => 3, 4]);
+       var_dump([...$iterator]);
+} catch (Error $ex) {
+       var_dump($ex->getMessage());
+}
+
+--EXPECT--
+string(36) "Cannot unpack array with string keys"
+string(42) "Cannot unpack Traversable with string keys"

diff --git a/Zend/tests/array_unpack/undef_var.phpt b/Zend/tests/array_unpack/undef_var.phpt
new file mode 100644 (file)
index 0000000..fff1f61
--- /dev/null
+++ b/Zend/tests/array_unpack/undef_var.phpt
@@ -0,0 +1,14 @@
+--TEST--
+array unpacking with undefinded variable
+--FILE--
+<?php
+
+var_dump([...$arr]);
+
+--EXPECTF--
+Notice: Undefined variable: arr in %s on line %d
+
+Fatal error: Uncaught Error: Only arrays and Traversables can be unpacked in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d
\ No newline at end of file

diff --git a/Zend/tests/array_unpack/unpack_invalid_type_compile_time.phpt b/Zend/tests/array_unpack/unpack_invalid_type_compile_time.phpt
new file mode 100644 (file)
index 0000000..1929743
--- /dev/null
+++ b/Zend/tests/array_unpack/unpack_invalid_type_compile_time.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Unpacking non-array/Traversable detected at compile-time
+--FILE--
+<?php
+
+var_dump([...42]);
+
+?>
+--EXPECTF--
+Fatal error: Only arrays and Traversables can be unpacked in %s on line %d

diff --git a/Zend/tests/array_unpack/unpack_string_keys_compile_time.phpt b/Zend/tests/array_unpack/unpack_string_keys_compile_time.phpt
new file mode 100644 (file)
index 0000000..1401fb9
--- /dev/null
+++ b/Zend/tests/array_unpack/unpack_string_keys_compile_time.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Unpacking of string keys detected at compile-time
+--FILE--
+<?php
+
+var_dump([...['a' => 'b']]);
+
+?>
+--EXPECTF--
+Fatal error: Cannot unpack array with string keys in %s on line %d

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 2e57e07ab59acb7ef267846e01e1e579f2cde2aa..ea55f394c3ecea4c229c82d778f9a7c1e169d52a 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -446,6 +446,32 @@ static int zend_ast_add_array_element(zval *result, zval *offset, zval *expr)
        return SUCCESS;
 }
 
+static int zend_ast_add_unpacked_element(zval *result, zval *expr) {
+       if (EXPECTED(Z_TYPE_P(expr) == IS_ARRAY)) {
+               HashTable *ht = Z_ARRVAL_P(expr);
+               zval *val;
+               zend_string *key;
+               
+               ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
+                       if (key) {
+                               zend_throw_error(NULL, "Cannot unpack array with string keys");
+                               return FAILURE;
+                       } else {
+                               if (!zend_hash_next_index_insert(Z_ARRVAL_P(result), val)) {
+                                       zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
+                                       break;
+                               }
+                               Z_TRY_ADDREF_P(val);
+                       }
+               } ZEND_HASH_FOREACH_END();
+               return SUCCESS;
+       }
+
+       /* Objects or references cannot occur in a constant expression. */
+       zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
+       return FAILURE;
+}
+
 ZEND_API int ZEND_FASTCALL zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *scope)
 {
        zval op1, op2;
@@ -642,6 +668,19 @@ ZEND_API int ZEND_FASTCALL zend_ast_evaluate(zval *result, zend_ast *ast, zend_c
                                array_init(result);
                                for (i = 0; i < list->children; i++) {
                                        zend_ast *elem = list->child[i];
+                                       if (elem->kind == ZEND_AST_UNPACK) {
+                                               if (UNEXPECTED(zend_ast_evaluate(&op1, elem->child[0], scope) != SUCCESS)) {
+                                                       zval_ptr_dtor_nogc(result);
+                                                       return FAILURE;
+                                               }
+                                               if (UNEXPECTED(zend_ast_add_unpacked_element(result, &op1) != SUCCESS)) {
+                                                       zval_ptr_dtor_nogc(&op1);
+                                                       zval_ptr_dtor_nogc(result);
+                                                       return FAILURE;
+                                               }
+                                               zval_ptr_dtor_nogc(&op1);
+                                               continue;
+                                       }
                                        if (elem->child[1]) {
                                                if (UNEXPECTED(zend_ast_evaluate(&op1, elem->child[1], scope) != SUCCESS)) {
                                                        zval_ptr_dtor_nogc(result);

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 34ff16f870469d15f37aab77c8f4359f6ba0ffea..155844e2e082bddf2efa79f9527d4f9f9a30456a 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2535,6 +2535,11 @@ static void zend_compile_list_assign(
                                continue;
                        }
                }
+               
+               if (elem_ast->kind == ZEND_AST_UNPACK) {
+                       zend_error(E_COMPILE_ERROR,
+                                       "Spread operator is not supported in assignments");
+               }
 
                var_ast = elem_ast->child[0];
                key_ast = elem_ast->child[1];
@@ -6958,13 +6963,21 @@ static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
                        zend_error(E_COMPILE_ERROR, "Cannot use empty array elements in arrays");
                }
 
-               zend_eval_const_expr(&elem_ast->child[0]);
-               zend_eval_const_expr(&elem_ast->child[1]);
-
-               if (elem_ast->attr /* by_ref */ || elem_ast->child[0]->kind != ZEND_AST_ZVAL
-                       || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
-               ) {
-                       is_constant = 0;
+               if (elem_ast->kind != ZEND_AST_UNPACK) {
+                       zend_eval_const_expr(&elem_ast->child[0]);
+                       zend_eval_const_expr(&elem_ast->child[1]);
+                       
+                       if (elem_ast->attr /* by_ref */ || elem_ast->child[0]->kind != ZEND_AST_ZVAL
+                               || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
+                       ) {
+                               is_constant = 0;
+                       }
+               } else {
+                       zend_eval_const_expr(&elem_ast->child[0]);
+                       
+                       if (elem_ast->child[0]->kind != ZEND_AST_ZVAL) {
+                               is_constant = 0;
+                       }
                }
 
                last_elem_ast = elem_ast;
@@ -6986,6 +6999,29 @@ static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
                zend_ast *key_ast = elem_ast->child[1];
 
                zval *value = zend_ast_get_zval(value_ast);
+               if (elem_ast->kind == ZEND_AST_UNPACK) {
+                       if (Z_TYPE_P(value) == IS_ARRAY) {
+                               HashTable *ht = Z_ARRVAL_P(value);
+                               zval *val;
+                               zend_string *key;
+
+                               ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
+                                       if (key) {
+                                               zend_error_noreturn(E_COMPILE_ERROR, "Cannot unpack array with string keys");
+                                       }
+                                       if (!zend_hash_next_index_insert(Z_ARRVAL_P(result), val)) {
+                                               zval_ptr_dtor(result);
+                                               return 0;
+                                       }
+                                       Z_TRY_ADDREF_P(val);
+                               } ZEND_HASH_FOREACH_END();
+               
+                               continue;
+                       } else {
+                               zend_error_noreturn(E_COMPILE_ERROR, "Only arrays and Traversables can be unpacked");
+                       }
+               } 
+               
                Z_TRY_ADDREF_P(value);
 
                if (key_ast) {
@@ -7744,6 +7780,16 @@ void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */
                key_ast = elem_ast->child[1];
                by_ref = elem_ast->attr;
 
+               if (elem_ast->kind == ZEND_AST_UNPACK) {
+                       zend_compile_expr(&value_node, value_ast);
+                       if (i == 0) {
+                               opline = zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL);
+                       }
+                       opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_UNPACK, &value_node, NULL);
+                       SET_NODE(opline->result, result);
+                       continue;
+               }
+
                if (key_ast) {
                        zend_compile_expr(&key_node, key_ast);
                        zend_handle_numeric_op(&key_node);
@@ -8070,6 +8116,7 @@ zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */
                || kind == ZEND_AST_UNARY_PLUS || kind == ZEND_AST_UNARY_MINUS
                || kind == ZEND_AST_CONDITIONAL || kind == ZEND_AST_DIM
                || kind == ZEND_AST_ARRAY || kind == ZEND_AST_ARRAY_ELEM
+               || kind == ZEND_AST_UNPACK
                || kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST
                || kind == ZEND_AST_CLASS_NAME
                || kind == ZEND_AST_MAGIC_CONST || kind == ZEND_AST_COALESCE;

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index 770a027fdac7aa642cb3e852f384c8edcc1099b7..22394868ba0159da4e688d19038e4911335a3f46 100644 (file)
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -1234,6 +1234,8 @@ array_pair:
                        { $$ = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $4, $1); }
        |       '&' variable
                        { $$ = zend_ast_create_ex(ZEND_AST_ARRAY_ELEM, 1, $2, NULL); }
+       |       T_ELLIPSIS expr
+                       { $$ = zend_ast_create(ZEND_AST_UNPACK, $2); }
        |       expr T_DOUBLE_ARROW T_LIST '(' array_pair_list ')'
                        { $5->attr = ZEND_ARRAY_SYNTAX_LIST;
                          $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $5, $1); }

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index a44a7c562d203630a67aa791cce78722037fe855..7d70d297d4b072def5cdbd26dfb77db3fa11f263 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -573,6 +573,7 @@ static void emit_live_range(
        switch (def_opline->opcode) {
                /* These should never be the first def. */
                case ZEND_ADD_ARRAY_ELEMENT:
+               case ZEND_ADD_ARRAY_UNPACK:
                case ZEND_ROPE_ADD:
                        ZEND_ASSERT(0);
                        return;
@@ -699,7 +700,8 @@ static void emit_live_range(
 static zend_bool is_fake_def(zend_op *opline) {
        /* These opcodes only modify the result, not create it. */
        return opline->opcode == ZEND_ROPE_ADD
-               || opline->opcode == ZEND_ADD_ARRAY_ELEMENT;
+               || opline->opcode == ZEND_ADD_ARRAY_ELEMENT
+               || opline->opcode == ZEND_ADD_ARRAY_UNPACK;
 }
 
 static zend_bool keeps_op1_alive(zend_op *opline) {

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 286227fa34602d9f82d2e1341493389f62570aad..8fae94fc494f99b8c8cda1927c3f6b7089655d8f 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -5554,7 +5554,114 @@ ZEND_VM_C_LABEL(num_index):
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, ARRAY_INIT|REF)
+ZEND_VM_HANDLER(208, ZEND_ADD_ARRAY_UNPACK, ANY, ANY)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *op1;
+       
+       SAVE_OPLINE();
+       op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
+       
+ZEND_VM_C_LABEL(add_again):
+       if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
+               HashTable *ht = Z_ARRVAL_P(op1);
+               zval *val;
+               zend_string *key;
+
+               ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
+                       if (key) {
+                               zend_throw_error(NULL, "Cannot unpack array with string keys");
+                               FREE_OP1();
+                               HANDLE_EXCEPTION();
+                       } else {
+                               if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
+                                       val = Z_REFVAL_P(val);
+                               }
+                               Z_TRY_ADDREF_P(val);
+                               if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
+                                       zend_cannot_add_element();
+                                       zval_ptr_dtor_nogc(val);
+                                       break;
+                               }
+                       }
+               } ZEND_HASH_FOREACH_END();
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+               zend_class_entry *ce = Z_OBJCE_P(op1);
+               zend_object_iterator *iter;
+
+               if (!ce || !ce->get_iterator) {
+                       zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
+               } else {
+                       iter = ce->get_iterator(ce, op1, 0);
+                       if (UNEXPECTED(!iter)) {
+                               FREE_OP1();
+                               if (!EG(exception)) {
+                                       zend_throw_exception_ex(
+                                               NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
+                                       );
+                               }
+                               HANDLE_EXCEPTION();
+                       }
+                       
+                       if (iter->funcs->rewind) {
+                               iter->funcs->rewind(iter);
+                       }
+                       
+                       for (; iter->funcs->valid(iter) == SUCCESS; ) {
+                               zval *val;
+
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       break;
+                               }
+
+                               val = iter->funcs->get_current_data(iter);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       break;
+                               }
+
+                               if (iter->funcs->get_current_key) {
+                                       zval key;
+                                       iter->funcs->get_current_key(iter, &key);
+                                       if (UNEXPECTED(EG(exception) != NULL)) {
+                                               break;
+                                       }
+
+                                       if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
+                                               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);
+                                               break;
+                                       }
+                               }
+
+                               ZVAL_DEREF(val);
+                               Z_TRY_ADDREF_P(val);
+
+                               if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
+                                       zend_cannot_add_element();
+                                       zval_ptr_dtor_nogc(val);
+                               }
+
+                               iter->funcs->move_forward(iter);
+                       }
+
+                       zend_iterator_dtor(iter);
+               }
+       } else if (EXPECTED(Z_ISREF_P(op1))) {
+               op1 = Z_REFVAL_P(op1);
+               ZEND_VM_C_GOTO(add_again);
+       } else {
+               zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
+       }
+       
+       FREE_OP1();
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|UNUSED|NEXT|CV, ARRAY_INIT|REF)
 {
        zval *array;
        uint32_t size;
@@ -5570,7 +5677,7 @@ ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|NEXT|
                }
                ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -7234,6 +7341,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
        if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
                switch (throw_op->opcode) {
                        case ZEND_ADD_ARRAY_ELEMENT:
+                       case ZEND_ADD_ARRAY_UNPACK:
                        case ZEND_ROPE_INIT:
                        case ZEND_ROPE_ADD:
                                break; /* exception while building structures, live range handling will free those */

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index e64eefe25565bb52cadc22b9d046b48d94924bc2..fbcd28de38f99310e8bf8fac0eb3ff9cd06f88fd 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1753,6 +1753,113 @@ send_array:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *op1;
+
+       SAVE_OPLINE();
+       op1 = get_zval_ptr(opline->op1_type, opline->op1, &free_op1, BP_VAR_R);
+
+add_again:
+       if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
+               HashTable *ht = Z_ARRVAL_P(op1);
+               zval *val;
+               zend_string *key;
+
+               ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
+                       if (key) {
+                               zend_throw_error(NULL, "Cannot unpack array with string keys");
+                               FREE_OP(free_op1);
+                               HANDLE_EXCEPTION();
+                       } else {
+                               if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
+                                       val = Z_REFVAL_P(val);
+                               }
+                               Z_TRY_ADDREF_P(val);
+                               if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
+                                       zend_cannot_add_element();
+                                       zval_ptr_dtor_nogc(val);
+                                       break;
+                               }
+                       }
+               } ZEND_HASH_FOREACH_END();
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+               zend_class_entry *ce = Z_OBJCE_P(op1);
+               zend_object_iterator *iter;
+
+               if (!ce || !ce->get_iterator) {
+                       zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
+               } else {
+                       iter = ce->get_iterator(ce, op1, 0);
+                       if (UNEXPECTED(!iter)) {
+                               FREE_OP(free_op1);
+                               if (!EG(exception)) {
+                                       zend_throw_exception_ex(
+                                               NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
+                                       );
+                               }
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (iter->funcs->rewind) {
+                               iter->funcs->rewind(iter);
+                       }
+
+                       for (; iter->funcs->valid(iter) == SUCCESS; ) {
+                               zval *val;
+
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       break;
+                               }
+
+                               val = iter->funcs->get_current_data(iter);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       break;
+                               }
+
+                               if (iter->funcs->get_current_key) {
+                                       zval key;
+                                       iter->funcs->get_current_key(iter, &key);
+                                       if (UNEXPECTED(EG(exception) != NULL)) {
+                                               break;
+                                       }
+
+                                       if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
+                                               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);
+                                               break;
+                                       }
+                               }
+
+                               ZVAL_DEREF(val);
+                               Z_TRY_ADDREF_P(val);
+
+                               if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
+                                       zend_cannot_add_element();
+                                       zval_ptr_dtor_nogc(val);
+                               }
+
+                               iter->funcs->move_forward(iter);
+                       }
+
+                       zend_iterator_dtor(iter);
+               }
+       } else if (EXPECTED(Z_ISREF_P(op1))) {
+               op1 = Z_REFVAL_P(op1);
+               goto add_again;
+       } else {
+               zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
+       }
+
+       FREE_OP(free_op1);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -2000,6 +2107,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(
        if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
                switch (throw_op->opcode) {
                        case ZEND_ADD_ARRAY_ELEMENT:
+                       case ZEND_ADD_ARRAY_UNPACK:
                        case ZEND_ROPE_INIT:
                        case ZEND_ROPE_ADD:
                                break; /* exception while building structures, live range handling will free those */
@@ -5831,7 +5939,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HA
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -8012,7 +8120,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_H
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -9211,7 +9319,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_H
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -10958,7 +11066,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDL
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -18997,7 +19105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HAND
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -19504,7 +19612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HAN
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -20088,7 +20196,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HAN
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -20557,7 +20665,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -24840,7 +24948,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HAND
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -27469,7 +27577,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HAN
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -29271,7 +29379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HAN
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -31878,7 +31986,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -34161,6 +34269,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       zval *array;
+       uint32_t size;
+       USE_OPLINE
+
+       array = EX_VAR(opline->result.var);
+       if (IS_UNUSED != IS_UNUSED) {
+               size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+               ZVAL_ARR(array, zend_new_array(size));
+               /* Explicitly initialize array as not-packed if flag is set */
+               if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+                       zend_hash_real_init_mixed(Z_ARRVAL_P(array));
+               }
+               ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       } else {
+               ZVAL_ARR(array, zend_new_array(0));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -36025,6 +36154,27 @@ check_parent_and_self:
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       zval *array;
+       uint32_t size;
+       USE_OPLINE
+
+       array = EX_VAR(opline->result.var);
+       if (IS_UNUSED != IS_UNUSED) {
+               size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+               ZVAL_ARR(array, zend_new_array(size));
+               /* Explicitly initialize array as not-packed if flag is set */
+               if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+                       zend_hash_real_init_mixed(Z_ARRVAL_P(array));
+               }
+               ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       } else {
+               ZVAL_ARR(array, zend_new_array(0));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -36679,6 +36829,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       zval *array;
+       uint32_t size;
+       USE_OPLINE
+
+       array = EX_VAR(opline->result.var);
+       if (IS_UNUSED != IS_UNUSED) {
+               size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+               ZVAL_ARR(array, zend_new_array(size));
+               /* Explicitly initialize array as not-packed if flag is set */
+               if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+                       zend_hash_real_init_mixed(Z_ARRVAL_P(array));
+               }
+               ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       } else {
+               ZVAL_ARR(array, zend_new_array(0));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -38621,6 +38792,27 @@ check_parent_and_self:
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       zval *array;
+       uint32_t size;
+       USE_OPLINE
+
+       array = EX_VAR(opline->result.var);
+       if (IS_UNUSED != IS_UNUSED) {
+               size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+               ZVAL_ARR(array, zend_new_array(size));
+               /* Explicitly initialize array as not-packed if flag is set */
+               if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+                       zend_hash_real_init_mixed(Z_ARRVAL_P(array));
+               }
+               ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       } else {
+               ZVAL_ARR(array, zend_new_array(0));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -44033,7 +44225,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDL
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -48142,7 +48334,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HAND
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -50220,7 +50412,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HAND
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -54217,7 +54409,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(
                }
                ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
-               ZVAL_EMPTY_ARRAY(array);
+               ZVAL_ARR(array, zend_new_array(0));
                ZEND_VM_NEXT_OPCODE();
        }
 }
@@ -56496,11 +56688,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
                        (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
-                       (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
+                       (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
+                       (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
+                       (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
                        (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
@@ -58231,6 +58423,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
                        (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -59319,6 +59512,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_SEND_ARRAY_SPEC)
                                ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
+                               VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
+                               ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
                                VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
                                ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63269,6 +63466,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
                                ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
+                               VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
+                               ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
                                VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
                                ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63409,6 +63610,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
+                               VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
+                               ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
                                VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
                                ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63441,6 +63646,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
                                ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
+                               VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
+                               ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
                                VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
                                ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63597,6 +63806,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
+                               VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
+                               ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
                                VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
                                ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -67339,11 +67552,11 @@ void zend_vm_init(void)
                ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
                ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
-               ZEND_NULL_HANDLER,
-               ZEND_NULL_HANDLER,
-               ZEND_NULL_HANDLER,
-               ZEND_NULL_HANDLER,
-               ZEND_NULL_HANDLER,
+               ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
+               ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
+               ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
+               ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
+               ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
                ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
                ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
                ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
@@ -69074,6 +69287,7 @@ void zend_vm_init(void)
                ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
                ZEND_JMP_FORWARD_SPEC_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -70114,9 +70328,9 @@ void zend_vm_init(void)
                2705,
                2706 | SPEC_RULE_OP1,
                2711,
-               4449,
+               4450,
                2712,
-               4449,
+               4450,
                2713 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
                2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2863,
@@ -70124,8 +70338,8 @@ void zend_vm_init(void)
                2865,
                2866 | SPEC_RULE_OP1,
                2871,
-               4449,
-               4449,
+               4450,
+               4450,
                2872,
                2873,
                2874,
@@ -70178,7 +70392,8 @@ void zend_vm_init(void)
                3505 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3530 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3555,
-               4449
+               3556,
+               4450
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -70385,7 +70600,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 = 3557 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3558 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -70393,7 +70608,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 = 3582 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3583 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -70401,7 +70616,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 = 3607 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3608 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -70412,17 +70627,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 = 3632 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3633 | 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 = 3657 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3658 | 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 = 3682 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3683 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -70433,17 +70648,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 = 3707 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3708 | 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 = 3732 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3733 | 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 = 3757 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3758 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_EQUAL:
@@ -70454,12 +70669,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 = 3782 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3783 | 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 = 3857 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3858 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_NOT_EQUAL:
@@ -70470,12 +70685,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 = 3932 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3933 | 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 = 4007 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4008 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_SMALLER:
@@ -70483,12 +70698,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 = 4082 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4083 | 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 = 4157 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4158 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -70496,75 +70711,75 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4232 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4233 | 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 = 4307 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4308 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 4400 | SPEC_RULE_OP1;
+                               spec = 4401 | 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 = 4405 | SPEC_RULE_OP1;
+                               spec = 4406 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4382 | SPEC_RULE_RETVAL;
+                               spec = 4383 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4384 | SPEC_RULE_RETVAL;
+                               spec = 4385 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4386 | SPEC_RULE_RETVAL;
+                               spec = 4387 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4388 | SPEC_RULE_RETVAL;
+                               spec = 4389 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4390 | SPEC_RULE_RETVAL;
+                               spec = 4391 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4392 | SPEC_RULE_RETVAL;
+                               spec = 4393 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4394;
-                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4395;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4396;
+                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                               spec = 4397;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4397;
-                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4398;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                       } else if (op1_info == MAY_BE_LONG) {
                                spec = 4399;
+                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
+                               spec = 4400;
                        }
                        break;
                case ZEND_JMP:
                        if (OP_JMP_ADDR(op, op->op1) > op) {
-                               spec = 3556;
+                               spec = 3557;
                        }
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 4445;
+                               spec = 4446;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4440 | SPEC_RULE_OP1;
+                               spec = 4441 | 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 = 4447 | SPEC_RULE_RETVAL;
+                               spec = 4448 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -70572,17 +70787,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 = 4410 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4411 | 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 = 4446;
+                               spec = 4447;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4435 | SPEC_RULE_OP1;
+                               spec = 4436 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 0fd402eeab8339a75c16d614a7f97a97c186ab52..09395d0b29ec85402701501c5873980d4b040b94 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -902,6 +902,11 @@
        _(1818, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
        _(1819, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
        _(1820, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
+       _(1821, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \
+       _(1822, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
+       _(1823, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
+       _(1824, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \
+       _(1825, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \
        _(1826, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
        _(1827, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
        _(1828, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
@@ -1836,495 +1841,496 @@
        _(3552, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \
        _(3553, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
        _(3555, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
-       _(3556, ZEND_JMP_FORWARD_SPEC) \
-       _(3562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3556, ZEND_ADD_ARRAY_UNPACK_SPEC) \
+       _(3557, ZEND_JMP_FORWARD_SPEC) \
+       _(3563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3566, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3565, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3577, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3579, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3581, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3587, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3580, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3588, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3589, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3591, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3592, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3590, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3592, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3593, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3594, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3602, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3603, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3597, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3603, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
        _(3604, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3606, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3605, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3607, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3616, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3615, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3627, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3629, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3631, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3630, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
        _(3634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3641, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3640, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3652, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3658, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3655, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
        _(3659, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3661, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3662, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3660, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3662, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3663, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3664, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3666, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3667, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3665, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3667, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3668, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3669, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3677, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3678, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3672, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3678, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
        _(3679, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3681, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3683, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3680, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3682, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
        _(3684, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3686, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3685, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3687, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3691, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3690, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3702, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3704, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3706, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3705, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3716, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3715, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3727, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
        _(3729, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3731, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3737, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3730, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3738, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3739, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3741, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3742, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3740, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3742, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3743, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3744, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3752, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3753, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3747, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3753, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
        _(3754, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3756, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3755, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3757, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3766, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3765, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3777, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
        _(3779, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3781, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4094, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(4095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(4143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4169, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(4245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(4293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(4305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(4320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(4321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(4322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(4368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(4369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(4370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(4380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(4381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(4382, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4384, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4385, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4386, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4387, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4390, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4391, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4392, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(4393, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(4394, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(4395, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
-       _(4396, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(4397, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(4398, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
-       _(4399, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(4400, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(4401, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3780, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4385, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4386, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4387, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4388, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4390, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4391, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4392, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4393, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4394, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4395, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4396, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+       _(4397, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4398, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4399, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+       _(4400, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4401, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
        _(4402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(4404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(4405, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(4406, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4405, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4406, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
        _(4407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(4409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(4411, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4410, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
        _(4412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(4414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(4415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(4416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4415, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
        _(4417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(4421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
        _(4422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(4430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(4431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4425, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
        _(4432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(4434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(4437, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(4439, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(4442, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(4444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(4445, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(4446, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(4447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(4448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(4448+1, ZEND_NULL)
+       _(4433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4435, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4438, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(4440, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(4443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(4445, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(4446, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(4447, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(4448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(4449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(4449+1, ZEND_NULL)

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 3e564782dcabaf911c555d51e7010b592cb9cf23..6e6bb770cbe90f4683f4bd7582ae94ba4554d0db 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[208] = {
+static const char *zend_vm_opcodes_names[209] = {
        "ZEND_NOP",
        "ZEND_ADD",
        "ZEND_SUB",
@@ -231,9 +231,10 @@ static const char *zend_vm_opcodes_names[208] = {
        "ZEND_POST_INC_STATIC_PROP",
        "ZEND_POST_DEC_STATIC_PROP",
        "ZEND_COPY_TMP",
+       "ZEND_ADD_ARRAY_UNPACK",
 };
 
-static uint32_t zend_vm_opcodes_flags[208] = {
+static uint32_t zend_vm_opcodes_flags[209] = {
        0x00000000,
        0x00000707,
        0x00000707,
@@ -442,6 +443,7 @@ static uint32_t zend_vm_opcodes_flags[208] = {
        0x00040307,
        0x00040307,
        0x00000105,
+       0x00000000,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) {

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 65efc4881652fbe57040af89b00884d7e50e3e20..ce2e020bc7eeed8da151017c121a52c815ea2470 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -280,7 +280,8 @@ END_EXTERN_C()
 #define ZEND_POST_INC_STATIC_PROP            205
 #define ZEND_POST_DEC_STATIC_PROP            206
 #define ZEND_COPY_TMP                        207
+#define ZEND_ADD_ARRAY_UNPACK                208
 
-#define ZEND_VM_LAST_OPCODE                  207
+#define ZEND_VM_LAST_OPCODE                  208
 
 #endif

diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index b8b122bf48096144ba566d736dfcbcf78d85ada0..8ed75e65d599f437aaa85e56b21fb7b3e5f835d1 100644 (file)
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -1664,6 +1664,7 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use
                                var_num = VAR_NUM(opline->result.var);
                                switch (opline->opcode) {
                                        case ZEND_ADD_ARRAY_ELEMENT:
+                                       case ZEND_ADD_ARRAY_UNPACK:
                                        case ZEND_ROPE_ADD:
                                                /* these opcodes use the result as argument */
                                                if (!zend_bitset_in(defined_here, var_num)) {
@@ -1781,6 +1782,7 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use
                                                        SET_UNUSED(opline->result);
                                                        break;
                                                case ZEND_ADD_ARRAY_ELEMENT:
+                                               case ZEND_ADD_ARRAY_UNPACK:
                                                case ZEND_ROPE_ADD:
                                                        zend_bitset_incl(usage, VAR_NUM(opline->result.var));
                                                        break;
@@ -1788,6 +1790,7 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use
                                } else {
                                        switch (opline->opcode) {
                                                case ZEND_ADD_ARRAY_ELEMENT:
+                                               case ZEND_ADD_ARRAY_UNPACK:
                                                case ZEND_ROPE_ADD:
                                                        break;
                                                default:

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 5f9f79b0186581ce9954e77a351be67dd4b0f438..202fe8165687bc75302a67d633e82e429b379aaa 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -515,6 +515,27 @@ static inline int ct_eval_add_array_elem(zval *result, zval *value, zval *key) {
        return SUCCESS;
 }
 
+static inline int ct_eval_add_array_unpack(zval *result, zval *array) {
+       zend_string *key;
+       zval *value;
+       if (Z_TYPE_P(array) != IS_ARRAY) {
+               return FAILURE;
+       }
+
+       SEPARATE_ARRAY(result);
+       ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(array), key, value) {
+               if (key) {
+                       return FAILURE;
+               }
+               value = zend_hash_next_index_insert(Z_ARR_P(result), value);
+               if (!value) {
+                       return FAILURE;
+               }
+               Z_TRY_ADDREF_P(value);
+       } ZEND_HASH_FOREACH_END();
+       return SUCCESS;
+}
+
 static inline int ct_eval_assign_dim(zval *result, zval *value, zval *key) {
        switch (Z_TYPE_P(result)) {
                case IS_NULL:
@@ -1332,6 +1353,31 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                        }
                        return;
                }
+               case ZEND_ADD_ARRAY_UNPACK: {
+                       zval *result = &ctx->values[ssa_op->result_use];
+                       if (IS_BOT(result) || IS_BOT(op1)) {
+                               SET_RESULT_BOT(result);
+                               return;
+                       }
+                       SKIP_IF_TOP(result);
+                       SKIP_IF_TOP(op1);
+
+                       /* See comment for ADD_ARRAY_ELEMENT. */
+                       if (Z_TYPE(ctx->values[ssa_op->result_def]) == IS_NULL) {
+                               SET_RESULT_BOT(result);
+                               return;
+                       }
+                       ZVAL_COPY_VALUE(&zv, result);
+                       ZVAL_NULL(result);
+
+                       if (ct_eval_add_array_unpack(&zv, op1) == SUCCESS) {
+                               SET_RESULT(result, &zv);
+                       } else {
+                               SET_RESULT_BOT(result);
+                       }
+                       zval_ptr_dtor_nogc(&zv);
+                       return;
+               }
                case ZEND_NEW:
                        if (ssa_op->result_def >= 0
                                        && ctx->scdf.ssa->vars[ssa_op->result_def].escape_state == ESCAPE_STATE_NO_ESCAPE) {
@@ -2168,7 +2214,8 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var,
                                                && opline->opcode != ZEND_ROPE_INIT
                                                && opline->opcode != ZEND_ROPE_ADD
                                                && opline->opcode != ZEND_INIT_ARRAY
-                                               && opline->opcode != ZEND_ADD_ARRAY_ELEMENT) {
+                                               && opline->opcode != ZEND_ADD_ARRAY_ELEMENT
+                                               && opline->opcode != ZEND_ADD_ARRAY_UNPACK) {
                                        /* Replace with QM_ASSIGN */
                                        zend_uchar old_type = opline->result_type;
                                        uint32_t old_var = opline->result.var;

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 5ac433b9505c13e7810d2d3ec814ab7ca74c132d..d6e3b4fa0da15b58475e31041f19003f35395b6a 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -3243,6 +3243,9 @@ static int zend_update_type_info(const zend_op_array *op_array,
                        }
                        if (ssa_ops[i].result_def >= 0) {
                                tmp = MAY_BE_RC1|MAY_BE_ARRAY;
+                               if (ssa_ops[i].result_use >= 0) {
+                                       tmp |= ssa_var_info[ssa_ops[i].result_use].type;
+                               }
                                if (opline->op1_type != IS_UNUSED) {
                                        tmp |= (t1 & MAY_BE_ANY) << MAY_BE_ARRAY_SHIFT;
                                        if (t1 & MAY_BE_UNDEF) {
@@ -3251,30 +3254,39 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                        if (opline->extended_value & ZEND_ARRAY_ELEMENT_REF) {
                                                tmp |= MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
                                        }
-                               }
-                               if (ssa_ops[i].result_use >= 0) {
-                                       tmp |= ssa_var_info[ssa_ops[i].result_use].type;
-                               }
-                               if (opline->op2_type == IS_UNUSED) {
-                                       tmp |= MAY_BE_ARRAY_KEY_LONG;
-                               } else {
-                                       if (t2 & (MAY_BE_LONG|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_DOUBLE)) {
+                                       if (opline->op2_type == IS_UNUSED) {
                                                tmp |= MAY_BE_ARRAY_KEY_LONG;
-                                       }
-                                       if (t2 & (MAY_BE_STRING)) {
-                                               tmp |= MAY_BE_ARRAY_KEY_STRING;
-                                               if (opline->op2_type != IS_CONST) {
-                                                       // FIXME: numeric string
+                                       } else {
+                                               if (t2 & (MAY_BE_LONG|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_DOUBLE)) {
                                                        tmp |= MAY_BE_ARRAY_KEY_LONG;
                                                }
-                                       }
-                                       if (t2 & (MAY_BE_UNDEF | MAY_BE_NULL)) {
-                                               tmp |= MAY_BE_ARRAY_KEY_STRING;
+                                               if (t2 & (MAY_BE_STRING)) {
+                                                       tmp |= MAY_BE_ARRAY_KEY_STRING;
+                                                       if (opline->op2_type != IS_CONST) {
+                                                               // FIXME: numeric string
+                                                               tmp |= MAY_BE_ARRAY_KEY_LONG;
+                                                       }
+                                               }
+                                               if (t2 & (MAY_BE_UNDEF | MAY_BE_NULL)) {
+                                                       tmp |= MAY_BE_ARRAY_KEY_STRING;
+                                               }
                                        }
                                }
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
                        }
                        break;
+               case ZEND_ADD_ARRAY_UNPACK:
+                       tmp = ssa_var_info[ssa_ops[i].result_use].type;
+                       ZEND_ASSERT(tmp & MAY_BE_ARRAY);
+                       /* Ignore string keys as they will throw. */
+                       if (t1 & MAY_BE_ARRAY_KEY_LONG) {
+                               tmp |= MAY_BE_ARRAY_KEY_LONG | (t1 & (MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF));
+                       }
+                       if (t1 & MAY_BE_OBJECT) {
+                               tmp |= MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_OF_ANY;
+                       }
+                       UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                       break;
                case ZEND_UNSET_CV:
                        tmp = MAY_BE_UNDEF;
                        if (!op_array->function_name) {

diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index 337ac1e96de09337388571fe5ee28efe560f97f0..d05610365732883b828f4096b0fad263f6e6445c 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -687,6 +687,9 @@ static int zend_ssa_rename(const zend_op_array *op_array, uint32_t build_flags,
                                                //NEW_SSA_VAR(opline+->op1.var)
                                        }
                                        break;
+                               case ZEND_ADD_ARRAY_UNPACK:
+                                       ssa_ops[k].result_use = var[EX_VAR_TO_NUM(opline->result.var)];
+                                       break;
                                case ZEND_SEND_VAR:
                                case ZEND_CAST:
                                case ZEND_QM_ASSIGN:

diff --git a/ext/opcache/Optimizer/zend_ssa.h b/ext/opcache/Optimizer/zend_ssa.h
index 5c69e4bd096f25715f4d1dd52291847d56aaa065..a921a5bbe0f0fb4106d6b241d4aa2cded9dcc91e 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.h
+++ b/ext/opcache/Optimizer/zend_ssa.h
@@ -220,7 +220,9 @@ static zend_always_inline zend_bool zend_ssa_is_no_val_use(const zend_op *opline
        if (opline->opcode == ZEND_FE_FETCH_R) {
                return ssa_op->op2_use == var && ssa_op->op1_use != var;
        }
-       if (ssa_op->result_use == var && opline->opcode != ZEND_ADD_ARRAY_ELEMENT) {
+       if (ssa_op->result_use == var
+                       && opline->opcode != ZEND_ADD_ARRAY_ELEMENT
+                       && opline->opcode != ZEND_ADD_ARRAY_UNPACK) {
                return ssa_op->op1_use != var && ssa_op->op2_use != var;
        }
        return 0;