Split ZEND_SEND_VAR_NO_REF into ZEND_SEND_VAR_NO_REF and ZEND_SEND_VAR_NO_REF_EX...

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index c6da34732aef70e314057d7fa1dfec3e24cab773..4bb712678f964dc95cd3333e1cce59282a1e54d6 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -3083,7 +3083,6 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                znode arg_node;
                zend_op *opline;
                zend_uchar opcode;
-               zend_ulong flags = 0;
 
                if (arg->kind == ZEND_AST_UNPACK) {
                        uses_arg_unpack = 1;
@@ -3109,13 +3108,16 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                                        /* Function call was converted into builtin instruction */
                                        opcode = ZEND_SEND_VAL;
                                } else {
-                                       opcode = ZEND_SEND_VAR_NO_REF;
-                                       flags |= ZEND_ARG_SEND_FUNCTION;
-                                       if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
-                                               flags |= ZEND_ARG_SEND_BY_REF;
-                                               if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
-                                                       flags |= ZEND_ARG_SEND_SILENT;
+                                       if (fbc) {
+                                               if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
+                                                       opcode = ZEND_SEND_VAR_NO_REF;
+                                               } else if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
+                                                       opcode = ZEND_SEND_VAL;
+                                               } else {
+                                                       opcode = ZEND_SEND_VAR;
                                                }
+                                       } else {
+                                               opcode = ZEND_SEND_VAR_NO_REF_EX;
                                        }
                                }
                        } else if (fbc) {
@@ -3135,9 +3137,17 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                        zend_compile_expr(&arg_node, arg);
                        ZEND_ASSERT(arg_node.op_type != IS_CV);
                        if (arg_node.op_type == IS_VAR) {
-                               opcode = ZEND_SEND_VAR_NO_REF;
-                               if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
-                                       flags |= ZEND_ARG_SEND_BY_REF;
+                               /* pass ++$a or something similar */
+                               if (fbc) {
+                                       if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
+                                               opcode = ZEND_SEND_VAR_NO_REF;
+                                       } else if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
+                                               opcode = ZEND_SEND_VAL;
+                                       } else {
+                                               opcode = ZEND_SEND_VAR;
+                                       }
+                               } else {
+                                       opcode = ZEND_SEND_VAR_NO_REF_EX;
                                }
                        } else {
                                if (fbc) {
@@ -3154,20 +3164,6 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                opline = zend_emit_op(NULL, opcode, &arg_node, NULL);
                opline->op2.opline_num = arg_num;
                opline->result.var = (uint32_t)(zend_intptr_t)ZEND_CALL_ARG(NULL, arg_num);
-
-               if (opcode == ZEND_SEND_VAR_NO_REF) {
-                       if (fbc) {
-                               flags |= ZEND_ARG_COMPILE_TIME_BOUND;
-                       }
-                       if ((flags & ZEND_ARG_COMPILE_TIME_BOUND) && !(flags & ZEND_ARG_SEND_BY_REF)) {
-                               opline->opcode = ZEND_SEND_VAR;
-                               opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND;
-                       } else {
-                               opline->extended_value = flags;
-                       }
-               } else if (fbc) {
-                       opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND;
-               }
        }
 
        return arg_count;

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 5ab0d0375bdb0118e4901e2b63f1836fea26dba8..fda7fe6014bd8b3189b59b36969b64f84c0b38dd 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -895,11 +895,6 @@ ZEND_API void zend_assert_valid_class_name(const zend_string *const_name);
 
 #define ZEND_FREE_ON_RETURN     (1<<0)
 
-#define ZEND_ARG_SEND_BY_REF (1<<0)
-#define ZEND_ARG_COMPILE_TIME_BOUND (1<<1)
-#define ZEND_ARG_SEND_FUNCTION (1<<2)
-#define ZEND_ARG_SEND_SILENT   (1<<3)
-
 #define ZEND_SEND_BY_VAL     0
 #define ZEND_SEND_BY_REF     1
 #define ZEND_SEND_PREFER_REF 2

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 893f113976b4befc9c49450a66303028dee10a36..8d97845bad5797ae479499bdcbd50cd976ed59a1 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -2468,6 +2468,7 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o
                                        case ZEND_SEND_VAR_EX:
                                        case ZEND_SEND_REF:
                                        case ZEND_SEND_VAR_NO_REF:
+                                       case ZEND_SEND_VAR_NO_REF_EX:
                                        case ZEND_SEND_USER:
                                                if (level == 0) {
                                                        ZEND_CALL_NUM_ARGS(call) = opline->op2.num;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 82ba60a03b0546668cefb8249589079f0fa4f691..e7fe591a9d87c5cf51254604d597991b94daf711 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4212,7 +4212,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV, JMP_ADDR)
        }
 }
 
-ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, NUM)
+ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMPVAR, NUM)
 {
        USE_OPLINE
        zval *value, *arg;
@@ -4299,25 +4299,15 @@ ZEND_VM_HANDLER(117, ZEND_SEND_VAR, VAR|CV, NUM)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM, SEND)
+ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM)
 {
        USE_OPLINE
        zend_free_op free_op1;
        zval *varptr, *arg;
 
-       if (!(opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND)) {
-               if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
-                       ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
-               }
-       }
-
        varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-       if (EXPECTED(Z_ISREF_P(varptr) ||
-           ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
-            ((opline->extended_value & ZEND_ARG_SEND_SILENT) != 0) :
-            ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num
-           )))) {
+       if (EXPECTED(Z_ISREF_P(varptr))) {
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -4333,6 +4323,52 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM, SEND)
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, NUM, SPEC(QUICK_ARG))
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varptr, *arg;
+       uint32_t arg_num = opline->op2.num;
+
+       if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
+               if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
+               }
+
+               varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       } else {
+               if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
+               }
+
+               varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       }
+
+       SAVE_OPLINE();
+       zend_error(E_NOTICE, "Only variables should be passed by reference");
+
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+       ZVAL_COPY_VALUE(arg, varptr);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM)
 {
        USE_OPLINE

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 3351a078b245a4e3df22390530c95bde547a4a88..7bd732acc287d11d69ad16ca5b89c9ebc191661f 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -12312,23 +12312,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OP
        HANDLE_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *value, *arg;
-       zend_free_op free_op1;
-
-       value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       ZVAL_COPY_VALUE(arg, value);
-       if (IS_TMP_VAR == IS_CONST) {
-               if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
-                       Z_ADDREF_P(arg);
-               }
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -15625,19 +15608,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDL
        zend_free_op free_op1;
        zval *varptr, *arg;
 
-       if (!(opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND)) {
-               if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) {
-                       ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-               }
-       }
-
        varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (EXPECTED(Z_ISREF_P(varptr) ||
-           ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
-            ((opline->extended_value & ZEND_ARG_SEND_SILENT) != 0) :
-            ARG_MAY_BE_SENT_BY_REF(EX(call)->func, opline->op2.num
-           )))) {
+       if (EXPECTED(Z_ISREF_P(varptr))) {
                arg = ZEND_CALL_VAR(EX(call), opline->result.var);
                ZVAL_COPY_VALUE(arg, varptr);
 
@@ -15653,6 +15626,98 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDL
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varptr, *arg;
+       uint32_t arg_num = opline->op2.num;
+
+       if (EXPECTED(0)) {
+               if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+               }
+
+               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       } else {
+               if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+               }
+
+               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       }
+
+       SAVE_OPLINE();
+       zend_error(E_NOTICE, "Only variables should be passed by reference");
+
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+       ZVAL_COPY_VALUE(arg, varptr);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varptr, *arg;
+       uint32_t arg_num = opline->op2.num;
+
+       if (EXPECTED(1)) {
+               if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+               }
+
+               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       } else {
+               if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
+                       ZEND_VM_TAIL_CALL(ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+               }
+
+               varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+               if (EXPECTED(Z_ISREF_P(varptr) ||
+                   ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
+                       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+                       ZVAL_COPY_VALUE(arg, varptr);
+
+                       ZEND_VM_NEXT_OPCODE();
+               }
+       }
+
+       SAVE_OPLINE();
+       zend_error(E_NOTICE, "Only variables should be passed by reference");
+
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+       ZVAL_COPY_VALUE(arg, varptr);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -54083,6 +54148,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZE
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *value, *arg;
+       zend_free_op free_op1;
+
+       value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+       ZVAL_COPY_VALUE(arg, value);
+       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+               if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
+                       Z_ADDREF_P(arg);
+               }
+       }
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -61650,6 +61732,16 @@ void zend_init_opcodes_handlers(void)
                ZEND_CASE_SPEC_CV_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_CASE_SPEC_CV_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_HANDLER,
+               ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_BOOL_SPEC_CONST_HANDLER,
                ZEND_BOOL_SPEC_TMPVAR_HANDLER,
                ZEND_BOOL_SPEC_TMPVAR_HANDLER,
@@ -61785,8 +61877,8 @@ void zend_init_opcodes_handlers(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_SEND_VAL_SPEC_CONST_HANDLER,
-               ZEND_SEND_VAL_SPEC_TMP_HANDLER,
-               ZEND_NULL_HANDLER,
+               ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER,
+               ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -64715,142 +64807,142 @@ void zend_init_opcodes_handlers(void)
                1423 | SPEC_RULE_OP1,
                1428 | SPEC_RULE_OP1,
                1433 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4471,
-               4471,
-               4471,
-               1458 | SPEC_RULE_OP1,
-               1463 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1488 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1513 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1538 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1563,
-               1564 | SPEC_RULE_OP1,
-               1569 | SPEC_RULE_OP2,
-               1574 | SPEC_RULE_RETVAL,
-               1576 | SPEC_RULE_OP2,
-               1581 | SPEC_RULE_OP1,
-               1586,
-               1587 | SPEC_RULE_OP2,
-               1592 | SPEC_RULE_OP1,
-               1597 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
-               1607 | SPEC_RULE_OP1,
-               1612 | SPEC_RULE_OP1,
-               1617 | SPEC_RULE_OP2,
+               4481,
+               1458 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
+               4481,
+               1468 | SPEC_RULE_OP1,
+               1473 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1498 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1523 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1548 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1573,
+               1574 | SPEC_RULE_OP1,
+               1579 | SPEC_RULE_OP2,
+               1584 | SPEC_RULE_RETVAL,
+               1586 | SPEC_RULE_OP2,
+               1591 | SPEC_RULE_OP1,
+               1596,
+               1597 | SPEC_RULE_OP2,
+               1602 | SPEC_RULE_OP1,
+               1607 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
+               1617 | SPEC_RULE_OP1,
                1622 | SPEC_RULE_OP1,
-               1627 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1652 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1677 | SPEC_RULE_OP1,
-               1682 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1707 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1732 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1757 | SPEC_RULE_OP1,
-               1762 | SPEC_RULE_OP1,
+               1627 | SPEC_RULE_OP2,
+               1632 | SPEC_RULE_OP1,
+               1637 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1662 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1687 | SPEC_RULE_OP1,
+               1692 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1717 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1742 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                1767 | SPEC_RULE_OP1,
-               1772 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1797 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1822 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1847 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1872 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1897 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1922 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1947 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1972 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1997 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2022 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2097 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2147 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2172 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2247 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4471,
-               2272,
-               2273,
-               2274,
-               2275,
-               2276,
-               2277 | SPEC_RULE_OP1,
-               2282 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2307 | SPEC_RULE_OP1,
-               2312 | SPEC_RULE_OP2,
+               1772 | SPEC_RULE_OP1,
+               1777 | SPEC_RULE_OP1,
+               1782 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1807 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1832 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1857 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1882 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1907 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1932 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1957 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1982 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2007 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2032 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2057 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2082 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2107 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2132 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2157 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2182 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2207 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2232 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2257 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               4481,
+               2282,
+               2283,
+               2284,
+               2285,
+               2286,
+               2287 | SPEC_RULE_OP1,
+               2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2317 | SPEC_RULE_OP1,
-               2322 | SPEC_RULE_OP1,
-               2327 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2352 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2377 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2402 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2427 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
-               2437 | SPEC_RULE_OP1,
-               2442 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2467,
-               2468 | SPEC_RULE_OP1,
-               2473 | SPEC_RULE_OP1,
+               2322 | SPEC_RULE_OP2,
+               2327 | SPEC_RULE_OP1,
+               2332 | SPEC_RULE_OP1,
+               2337 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2387 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2412 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2437 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
+               2447 | SPEC_RULE_OP1,
+               2452 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2477,
                2478 | SPEC_RULE_OP1,
                2483 | SPEC_RULE_OP1,
-               2488 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2513 | SPEC_RULE_OP1,
-               2518 | SPEC_RULE_OP1,
+               2488 | SPEC_RULE_OP1,
+               2493 | SPEC_RULE_OP1,
+               2498 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2523 | SPEC_RULE_OP1,
-               2528 | SPEC_RULE_OP2,
-               2533 | SPEC_RULE_RETVAL,
-               2535 | SPEC_RULE_RETVAL,
-               2537 | SPEC_RULE_RETVAL,
-               2539 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2564 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2589 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2614 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2639 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
-               2764,
-               2765 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2790,
-               2791 | SPEC_RULE_OP2,
-               2796,
-               2797 | SPEC_RULE_OP1,
-               2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2827 | SPEC_RULE_OP2,
-               2832 | SPEC_RULE_OP2,
-               2837,
-               2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
-               2963 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2988,
-               2989,
-               2990,
-               2991 | SPEC_RULE_OP1,
-               2996 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3021,
-               3022,
-               3023 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3048,
-               3049,
-               3050,
-               3051 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3076 | SPEC_RULE_OP1,
-               3081,
-               3082,
-               3083,
-               3084,
-               3085 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3110 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               3185 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3210 | SPEC_RULE_OP1,
-               3215 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3240,
-               3241 | SPEC_RULE_OP2,
-               3246 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3271 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3296 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3321 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3346 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3371 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3396 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3421 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3446 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3471 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3496 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4471
+               2528 | SPEC_RULE_OP1,
+               2533 | SPEC_RULE_OP1,
+               2538 | SPEC_RULE_OP2,
+               2543 | SPEC_RULE_RETVAL,
+               2545 | SPEC_RULE_RETVAL,
+               2547 | SPEC_RULE_RETVAL,
+               2549 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2599 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2624 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2649 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               2774,
+               2775 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2800,
+               2801 | SPEC_RULE_OP2,
+               2806,
+               2807 | SPEC_RULE_OP1,
+               2812 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2837 | SPEC_RULE_OP2,
+               2842 | SPEC_RULE_OP2,
+               2847,
+               2848 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               2973 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2998,
+               2999,
+               3000,
+               3001 | SPEC_RULE_OP1,
+               3006 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3031,
+               3032,
+               3033 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3058,
+               3059,
+               3060,
+               3061 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3086 | SPEC_RULE_OP1,
+               3091,
+               3092,
+               3093,
+               3094,
+               3095 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3220 | SPEC_RULE_OP1,
+               3225 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3250,
+               3251 | SPEC_RULE_OP2,
+               3256 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3281 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3306 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3331 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3356 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3381 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3406 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3431 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3456 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3481 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3506 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               4481
        };
        zend_opcode_handlers = labels;
                zend_handlers_count = sizeof(labels) / sizeof(void*);
@@ -64957,7 +65049,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3521 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3531 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64965,7 +65057,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3546 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3556 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64973,7 +65065,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3571 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3581 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64984,17 +65076,17 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3596 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3606 | 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 = 3621 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3631 | 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 = 3646 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3656 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -65002,7 +65094,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3671 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3681 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65010,7 +65102,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3696 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3706 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65018,7 +65110,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3721 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3731 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65029,7 +65121,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3746 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3756 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65037,7 +65129,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3821 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3831 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65048,7 +65140,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3896 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3906 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65056,7 +65148,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3971 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3981 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -65067,12 +65159,12 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4046 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4056 | 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 = 4121 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4131 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -65080,60 +65172,60 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4196 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4206 | 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 = 4271 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4281 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if ((op1_info == MAY_BE_DOUBLE)) {
-                               spec = 4436 | SPEC_RULE_OP1;
+                               spec = 4446 | SPEC_RULE_OP1;
                        } else if ((!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) {
-                               spec = 4441 | SPEC_RULE_OP1;
+                               spec = 4451 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if ((res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG)) {
-                               spec = 4346 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
-                       } else if ((op1_info == MAY_BE_LONG)) {
                                spec = 4356 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
-                       } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
+                       } else if ((op1_info == MAY_BE_LONG)) {
                                spec = 4366 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                       } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
+                               spec = 4376 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if ((res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG)) {
-                               spec = 4376 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
-                       } else if ((op1_info == MAY_BE_LONG)) {
                                spec = 4386 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
-                       } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
+                       } else if ((op1_info == MAY_BE_LONG)) {
                                spec = 4396 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                       } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
+                               spec = 4406 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if ((res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG)) {
-                               spec = 4406 | SPEC_RULE_OP1;
+                               spec = 4416 | SPEC_RULE_OP1;
                        } else if ((op1_info == MAY_BE_LONG)) {
-                               spec = 4411 | SPEC_RULE_OP1;
+                               spec = 4421 | SPEC_RULE_OP1;
                        } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
-                               spec = 4416 | SPEC_RULE_OP1;
+                               spec = 4426 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_POST_DEC:
                        if ((res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG)) {
-                               spec = 4421 | SPEC_RULE_OP1;
+                               spec = 4431 | SPEC_RULE_OP1;
                        } else if ((op1_info == MAY_BE_LONG)) {
-                               spec = 4426 | SPEC_RULE_OP1;
+                               spec = 4436 | SPEC_RULE_OP1;
                        } else if ((op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE))) {
-                               spec = 4431 | SPEC_RULE_OP1;
+                               spec = 4441 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
                        if ((!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF)))) {
-                               spec = 4446 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4456 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                default:

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 03d9817c6be4c0e39fb982370846cfa38609d3f5..e1041d24c1e26e1eeee91500ca7472f3a9247c5e 100644 (file)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -86,7 +86,7 @@ $vm_op_flags = array(
        // unused 0x09000000,
        // unused 0x0a000000,
        "ZEND_VM_EXT_SRC"         => 0x0b000000,
-       "ZEND_VM_EXT_SEND"        => 0x0c000000,
+       // unused 0x0c000000,
        "ZEND_VM_NO_CONST_CONST"  => 0x40000000,
        "ZEND_VM_COMMUTATIVE"     => 0x80000000,
 );
@@ -128,7 +128,6 @@ $vm_ext_decode = array(
        "ARG_NUM"              => ZEND_VM_EXT_ARG_NUM,
        "REF"                  => ZEND_VM_EXT_REF,
        "SRC"                  => ZEND_VM_EXT_SRC,
-       "SEND"                 => ZEND_VM_EXT_SEND,
 );
 
 $vm_kind_name = array(

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 5463f9c498863ba94dc0eb24a70c4ef61c39a681..100106cdc51b1a2a16e352fd37c56317e88af6f4 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -72,7 +72,7 @@ static const char *zend_vm_opcodes_names[184] = {
        "ZEND_JMPNZ_EX",
        "ZEND_CASE",
        NULL,
-       NULL,
+       "ZEND_SEND_VAR_NO_REF_EX",
        NULL,
        "ZEND_BOOL",
        "ZEND_FAST_CONCAT",
@@ -259,7 +259,7 @@ static uint32_t zend_vm_opcodes_flags[184] = {
        0x00002007,
        0x00000707,
        0x00000000,
-       0x00000000,
+       0x00001001,
        0x00000000,
        0x00000007,
        0x00000707,
@@ -274,7 +274,7 @@ static uint32_t zend_vm_opcodes_flags[184] = {
        0x00000003,
        0x00000010,
        0x00000310,
-       0x00001003,
+       0x00001007,
        0x00001001,
        0x00001001,
        0x01000073,
@@ -315,7 +315,7 @@ static uint32_t zend_vm_opcodes_flags[184] = {
        0x00000000,
        0x00000000,
        0x01000000,
-       0x0c001001,
+       0x00001001,
        0x03000103,
        0x00000003,
        0x05000700,

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 4f5a0d615a27dcd3b847bbf2718543b7d6a47946..1eb54f0f005e6b380d61687ab37b52631c156e96 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -55,7 +55,6 @@
 #define ZEND_VM_EXT_TYPE         0x07000000
 #define ZEND_VM_EXT_EVAL         0x08000000
 #define ZEND_VM_EXT_SRC          0x0b000000
-#define ZEND_VM_EXT_SEND         0x0c000000
 #define ZEND_VM_NO_CONST_CONST   0x40000000
 #define ZEND_VM_COMMUTATIVE      0x80000000
 #define ZEND_VM_OP1_FLAGS(flags) (flags & 0xff)
@@ -117,6 +116,7 @@ END_EXTERN_C()
 #define ZEND_JMPZ_EX                          46
 #define ZEND_JMPNZ_EX                         47
 #define ZEND_CASE                             48
+#define ZEND_SEND_VAR_NO_REF_EX               50
 #define ZEND_BOOL                             52
 #define ZEND_FAST_CONCAT                      53
 #define ZEND_ROPE_INIT                        54

diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c
index b37e0fee57f9ca004683c6edbb08289909a0c1fd..75120d250120c999f8de613d37276d13b0f82195 100644 (file)
--- a/ext/opcache/Optimizer/optimize_func_calls.c
+++ b/ext/opcache/Optimizer/optimize_func_calls.c
@@ -145,19 +145,20 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
                                        }
                                }
                                break;
-                       case ZEND_SEND_VAR_NO_REF:
-                               if (!(opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) && call_stack[call - 1].func) {
-                                       if (ARG_SHOULD_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) {
-                                               opline->extended_value |= ZEND_ARG_COMPILE_TIME_BOUND | ZEND_ARG_SEND_BY_REF;
+                       case ZEND_SEND_VAR_NO_REF_EX:
+                               if (call_stack[call - 1].func) {
+                                       if (ARG_MUST_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) {
+                                               opline->opcode = ZEND_SEND_VAR_NO_REF;
+                                       } else if (ARG_MAY_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) {
+                                               opline->opcode = ZEND_SEND_VAL;
                                        } else {
                                                opline->opcode = ZEND_SEND_VAR;
-                                               opline->extended_value = 0;
                                        }
                                }
                                break;
 #if 0
                        case ZEND_SEND_REF:
-                               if (opline->extended_value != ZEND_ARG_COMPILE_TIME_BOUND && call_stack[call - 1].func) {
+                               if (call_stack[call - 1].func) {
                                        /* We won't handle run-time pass by reference */
                                        call_stack[call - 1].opline = NULL;
                                }

diff --git a/ext/opcache/Optimizer/zend_call_graph.c b/ext/opcache/Optimizer/zend_call_graph.c
index c7bc7b2e3ec7fefaaa627a68961c2fd65e68a84d..53eb0a84ea116563289554d952ecca5679af1039 100644 (file)
--- a/ext/opcache/Optimizer/zend_call_graph.c
+++ b/ext/opcache/Optimizer/zend_call_graph.c
@@ -104,6 +104,7 @@ static void zend_collect_args_info(zend_call_info *call_info)
                        case ZEND_SEND_VAR_EX:
                        case ZEND_SEND_REF:
                        case ZEND_SEND_VAR_NO_REF:
+                       case ZEND_SEND_VAR_NO_REF_EX:
                                num = opline->op2.num;
                                if (num > 0) {
                                        num--;

diff --git a/ext/opcache/Optimizer/zend_dfg.c b/ext/opcache/Optimizer/zend_dfg.c
index d5be92d317053dca376727b2dbfac93b2e57b3ba..97fc846d3c824713673a55979ef127f1b4c3ba69 100644 (file)
--- a/ext/opcache/Optimizer/zend_dfg.c
+++ b/ext/opcache/Optimizer/zend_dfg.c
@@ -93,6 +93,7 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg
                                        case ZEND_SEND_VAR_EX:
                                        case ZEND_SEND_REF:
                                        case ZEND_SEND_VAR_NO_REF:
+                                       case ZEND_SEND_VAR_NO_REF_EX:
                                        case ZEND_FE_RESET_RW:
                                        case ZEND_ASSIGN_ADD:
                                        case ZEND_ASSIGN_SUB:

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index c306c7ac1e3fc1f6d79bee3565307d2895a0fc37..7c225bbbe8618a9a51ed8330f0423ec94dab7010 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -504,19 +504,6 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
                } else if (opline->extended_value == ZEND_RETURNS_FUNCTION) {
                        fprintf(stderr, " (function)");
                }
-       } else if (ZEND_VM_EXT_SEND == (flags & ZEND_VM_EXT_MASK)) {
-               if (opline->extended_value & ZEND_ARG_SEND_BY_REF) {
-                       fprintf(stderr, " (ref)");
-               }
-               if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) {
-                       fprintf(stderr, " (compile-time)");
-               }
-               if (opline->extended_value & ZEND_ARG_SEND_FUNCTION) {
-                       fprintf(stderr, " (function)");
-               }
-               if (opline->extended_value & ZEND_ARG_SEND_SILENT) {
-                       fprintf(stderr, " (silent)");
-               }
        } else {
                if (ZEND_VM_EXT_VAR_FETCH & flags) {
                        switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 168609f9a0b59a37257f449ffaf6729bc68d5dc8..8ea4347d50cd746aee263aeee3561d27e4f231de 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2841,6 +2841,7 @@ static void zend_update_type_info(const zend_op_array *op_array,
                        break;
                case ZEND_SEND_VAR_EX:
                case ZEND_SEND_VAR_NO_REF:
+               case ZEND_SEND_VAR_NO_REF_EX:
                case ZEND_SEND_REF:
 // TODO: ???
                        if (ssa_ops[i].op1_def >= 0) {
@@ -3197,6 +3198,7 @@ static void zend_update_type_info(const zend_op_array *op_array,
                                                        break;
                                                case ZEND_SEND_VAR_EX:
                                                case ZEND_SEND_VAR_NO_REF:
+                                               case ZEND_SEND_VAR_NO_REF_EX:
                                                case ZEND_SEND_REF:
                                                case ZEND_ASSIGN_REF:
                                                        tmp |= MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 1e4e092512bad2c6e67de006d03f68d878b4fb5f..dd1a9200aa27a22aa84b5fcb7547127773a88093 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -419,17 +419,10 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array,
                                        opline->opcode = ZEND_SEND_VAL_EX;
                                        break;
                                case ZEND_SEND_VAR_NO_REF:
-                                       if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) {
-                                               if (opline->extended_value & ZEND_ARG_SEND_BY_REF) {
-                                                       zval_dtor(val);
-                                                       return 0;
-                                               }
-                                               opline->extended_value = 0;
-                                               opline->opcode = ZEND_SEND_VAL_EX;
-                                       } else {
-                                               opline->extended_value = 0;
-                                               opline->opcode = ZEND_SEND_VAL;
-                                       }
+                                       zval_dtor(val);
+                                       return 0;
+                               case ZEND_SEND_VAR_NO_REF_EX:
+                                       opline->opcode = ZEND_SEND_VAL;
                                        break;
                                case ZEND_SEND_USER:
                                        opline->opcode = ZEND_SEND_VAL_EX;

diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index 498d2f1da9873736305957773b051831dc5d7c90..fc55acf5275607fed79257cf1f4294f203c9da4a 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -625,6 +625,7 @@ static int zend_ssa_rename(const zend_op_array *op_array, uint32_t build_flags,
                                        }
                                        break;
                                case ZEND_SEND_VAR_NO_REF:
+                               case ZEND_SEND_VAR_NO_REF_EX:
                                case ZEND_SEND_VAR_EX:
                                case ZEND_SEND_REF:
                                case ZEND_SEND_UNPACK: