Slit INC/DEC opcodes into hot/cold parts and remove specialized versioins for LONG_OR...

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 9aedf8bebb010d4e72a0dbc00f685000f73b004d..b20df489c755f58b0110db6ae33d9bb64aac247a 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1523,7 +1523,7 @@ ZEND_VM_HANDLER(41, ZEND_POST_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
        ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_STATIC_PROP);
 }
 
-ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
+ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1531,14 +1531,6 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
 
        var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
 
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -1572,7 +1564,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1581,13 +1573,24 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
        var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
+               fast_long_increment_function(var_ptr);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_DISPATCH_TO_HELPER(zend_pre_inc_helper);
+}
+
+ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
+
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -1622,7 +1625,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
+ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1631,11 +1634,24 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
        var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_increment_function(var_ptr);
+               fast_long_decrement_function(var_ptr);
+               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+               }
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_DISPATCH_TO_HELPER(zend_pre_dec_helper);
+}
+
+ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
+
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -1666,7 +1682,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
+ZEND_VM_HOT_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1676,10 +1692,21 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_decrement_function(var_ptr);
+               fast_long_increment_function(var_ptr);
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_DISPATCH_TO_HELPER(zend_post_inc_helper);
+}
+
+ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
+
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -1710,6 +1737,23 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HOT_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
+
+       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+               fast_long_decrement_function(var_ptr);
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       ZEND_VM_DISPATCH_TO_HELPER(zend_post_dec_helper);
+}
+
 ZEND_VM_HANDLER(136, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
 {
        USE_OPLINE
@@ -8996,23 +9040,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_INC_LONG_OR_DOUBLE, CV, ANY, SPEC(RETVAL))
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)++;
-       }
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
 {
        USE_OPLINE
@@ -9039,23 +9066,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_DEC_LONG_OR_DOUBLE, CV, ANY, SPEC(RETVAL))
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)--;
-       }
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG_NO_OVERFLOW, CV, ANY)
 {
        USE_OPLINE
@@ -9078,22 +9088,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POS
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_INC_LONG_OR_DOUBLE, CV, ANY)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_increment_function(var_ptr);
-       } else {
-               ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-               Z_DVAL_P(var_ptr)++;
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG_NO_OVERFLOW, CV, ANY)
 {
        USE_OPLINE
@@ -9116,22 +9110,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POS
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_DEC_LONG_OR_DOUBLE, CV, ANY)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_decrement_function(var_ptr);
-       } else {
-               ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-               Z_DVAL_P(var_ptr)--;
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_QM_ASSIGN, (op1_info == MAY_BE_DOUBLE), ZEND_QM_ASSIGN_DOUBLE, CONST|TMPVARCV, ANY)
 {
        USE_OPLINE

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index d7084d6f10928cc06a140854fe0cffadee6e65a7..41a3ccf03334c06c2023e2960cebdf9e38d4e1ab 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -440,7 +440,7 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS);
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS);
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -461,7 +461,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(zval *op_1, zv
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -482,7 +482,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(zval *op_1, zv
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -513,7 +513,7 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mo
        HANDLE_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -534,7 +534,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(zval *op_1, zv
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -555,7 +555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(zval *o
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -576,7 +576,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(zval *
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -608,7 +608,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(zval *op_
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -640,7 +640,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -672,7 +672,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *o
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -704,7 +704,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPE
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -725,7 +725,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1,
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -746,7 +746,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(zval *op_1,
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -888,7 +888,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
        zval *prop;
@@ -1136,7 +1136,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_execute_data *old_execute_data;
        uint32_t call_info = EX_CALL_INFO();
@@ -2117,7 +2117,7 @@ send_array:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -2482,7 +2482,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(Z
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset, uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset, uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        /* May be NULL during generator closing (only finally blocks are executed) */
        zend_object *ex = EG(exception);
@@ -2844,7 +2844,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_H
        ZEND_VM_CONTINUE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 {
        EG(vm_interrupt) = 0;
        if (EG(timed_out)) {
@@ -8587,7 +8587,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
        ZEND_VM_RETURN();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -15343,7 +15343,7 @@ try_instanceof:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19042,7 +19042,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19050,16 +19050,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(0)) {
+               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
                ZEND_VM_NEXT_OPCODE();
@@ -19083,7 +19075,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED
                increment_function(var_ptr);
        } while (0);
 
-       if (UNEXPECTED(0)) {
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
@@ -19091,7 +19083,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19101,46 +19093,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_H
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
-               if (UNEXPECTED(1)) {
+               if (UNEXPECTED(0)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       SAVE_OPLINE();
-       if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
-               ZVAL_NULL(var_ptr);
-               ZVAL_UNDEFINED_OP1();
-       }
-
-       do {
-               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                       zend_reference *ref = Z_REF_P(var_ptr);
-                       var_ptr = Z_REFVAL_P(var_ptr);
-                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                               zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
-                               break;
-                       }
-               }
-               increment_function(var_ptr);
-       } while (0);
-
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
-       }
-
-       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19149,15 +19111,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
-               if (UNEXPECTED(0)) {
+               fast_long_increment_function(var_ptr);
+               if (UNEXPECTED(1)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(0)) {
+               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
                ZEND_VM_NEXT_OPCODE();
@@ -19182,7 +19155,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED
                decrement_function(var_ptr);
        } while (0);
 
-       if (UNEXPECTED(0)) {
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
@@ -19190,7 +19163,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19200,47 +19173,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_H
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
-               if (UNEXPECTED(1)) {
+               if (UNEXPECTED(0)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
 
-       SAVE_OPLINE();
-       if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
-               ZVAL_NULL(var_ptr);
-               ZVAL_UNDEFINED_OP1();
-       }
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
 
-       do {
-               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                       zend_reference *ref = Z_REF_P(var_ptr);
-                       var_ptr = Z_REFVAL_P(var_ptr);
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                               zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
-                               break;
-                       }
+       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+               fast_long_decrement_function(var_ptr);
+               if (UNEXPECTED(1)) {
+                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
-               decrement_function(var_ptr);
-       } while (0);
-
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+               ZEND_VM_NEXT_OPCODE();
        }
 
-       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19248,12 +19209,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_increment_function(var_ptr);
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -19284,7 +19239,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -19294,10 +19249,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_decrement_function(var_ptr);
+               fast_long_increment_function(var_ptr);
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -19328,6 +19294,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *var_ptr;
+
+       var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+               fast_long_decrement_function(var_ptr);
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -35369,7 +35352,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35377,16 +35360,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_
 
        var_ptr = EX_VAR(opline->op1.var);
 
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(0)) {
+               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
                ZEND_VM_NEXT_OPCODE();
@@ -35410,14 +35385,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_
                increment_function(var_ptr);
        } while (0);
 
-       if (UNEXPECTED(0)) {
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35427,45 +35402,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HA
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_increment_function(var_ptr);
-               if (UNEXPECTED(1)) {
+               if (UNEXPECTED(0)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
-               ZVAL_NULL(var_ptr);
-               ZVAL_UNDEFINED_OP1();
-       }
-
-       do {
-               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                       zend_reference *ref = Z_REF_P(var_ptr);
-                       var_ptr = Z_REFVAL_P(var_ptr);
-                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                               zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
-                               break;
-                       }
-               }
-               increment_function(var_ptr);
-       } while (0);
-
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
-       }
-
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35474,15 +35420,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_
        var_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
-               if (UNEXPECTED(0)) {
+               fast_long_increment_function(var_ptr);
+               if (UNEXPECTED(1)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *var_ptr;
+
+       var_ptr = EX_VAR(opline->op1.var);
+
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(0)) {
+               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
                ZEND_VM_NEXT_OPCODE();
@@ -35507,14 +35464,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_
                decrement_function(var_ptr);
        } while (0);
 
-       if (UNEXPECTED(0)) {
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35524,46 +35481,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HA
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                fast_long_decrement_function(var_ptr);
-               if (UNEXPECTED(1)) {
+               if (UNEXPECTED(0)) {
                        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
                }
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
 
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
-               ZVAL_NULL(var_ptr);
-               ZVAL_UNDEFINED_OP1();
-       }
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
 
-       do {
-               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                       zend_reference *ref = Z_REF_P(var_ptr);
-                       var_ptr = Z_REFVAL_P(var_ptr);
+       zval *var_ptr;
 
-                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                               zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
-                               break;
-                       }
-               }
-               decrement_function(var_ptr);
-       } while (0);
+       var_ptr = EX_VAR(opline->op1.var);
 
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+               fast_long_decrement_function(var_ptr);
+               if (UNEXPECTED(1)) {
+                       ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+               }
+               ZEND_VM_NEXT_OPCODE();
        }
 
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35571,12 +35517,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_
 
        var_ptr = EX_VAR(opline->op1.var);
 
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_increment_function(var_ptr);
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -35606,7 +35546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
@@ -35616,10 +35556,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_
 
        if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_decrement_function(var_ptr);
+               fast_long_increment_function(var_ptr);
                ZEND_VM_NEXT_OPCODE();
        }
 
+       ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *var_ptr;
+
+       var_ptr = EX_VAR(opline->op1.var);
+
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -35649,6 +35600,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *var_ptr;
+
+       var_ptr = EX_VAR(opline->op1.var);
+
+       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+               fast_long_decrement_function(var_ptr);
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -37016,40 +36984,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)++;
-       }
-       if (UNEXPECTED(0)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_increment_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)++;
-       }
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -37102,40 +37036,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)--;
-       }
-       if (UNEXPECTED(0)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               fast_long_decrement_function(var_ptr);
-       } else {
-               Z_DVAL_P(var_ptr)--;
-       }
-       if (UNEXPECTED(1)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -37158,22 +37058,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_increment_function(var_ptr);
-       } else {
-               ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-               Z_DVAL_P(var_ptr)++;
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -37196,22 +37080,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC
        ZEND_VM_NEXT_OPCODE();
 }
 
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *var_ptr;
-
-       var_ptr = EX_VAR(opline->op1.var);
-       if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-               fast_long_decrement_function(var_ptr);
-       } else {
-               ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-               Z_DVAL_P(var_ptr)--;
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -43973,7 +43841,7 @@ assign_dim_op_ret_null:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
 
@@ -51362,20 +51230,14 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
                        (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
                        (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
-                       (void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_LABEL,
-                       (void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_LABEL,
                        (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
                        (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
                        (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
                        (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
-                       (void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_LABEL,
-                       (void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_LABEL,
                        (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
                        (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
-                       (void*)&&ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_LABEL,
                        (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
                        (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
-                       (void*)&&ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_LABEL,
                        (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
                        (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
                        (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
@@ -54744,14 +54606,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
                                ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED):
-                               VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED)
-                               ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED):
-                               VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED)
-                               ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
                                VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
                                ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -54768,14 +54622,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
                                ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED):
-                               VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED)
-                               ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED):
-                               VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED)
-                               ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
                                VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
                                ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -54784,10 +54630,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
                                ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV):
-                               VM_TRACE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV)
-                               ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
                                VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
                                ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -54796,10 +54638,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
                                ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV):
-                               VM_TRACE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV)
-                               ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
                                VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
                                ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58571,20 +58409,14 @@ void zend_vm_init(void)
                ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
                ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
                ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
-               ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER,
-               ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER,
                ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
                ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
                ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
                ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
-               ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER,
-               ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER,
                ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
                ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
-               ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER,
                ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
                ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
-               ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER,
                ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
                ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
                ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
@@ -58832,7 +58664,7 @@ void zend_vm_init(void)
                2080,
                2081 | SPEC_RULE_OP1,
                2086 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3004
+               2998
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -59141,9 +58973,9 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 2955 | SPEC_RULE_OP1;
+                               spec = 2949 | 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 = 2960 | SPEC_RULE_OP1;
+                               spec = 2954 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
@@ -59151,35 +58983,27 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                                spec = 2937 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
                                spec = 2939 | SPEC_RULE_RETVAL;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 2941 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 2943 | SPEC_RULE_RETVAL;
+                               spec = 2941 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 2945 | SPEC_RULE_RETVAL;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 2947 | SPEC_RULE_RETVAL;
+                               spec = 2943 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 2949;
+                               spec = 2945;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 2950;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 2951;
+                               spec = 2946;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 2952;
+                               spec = 2947;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 2953;
-                       } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 2954;
+                               spec = 2948;
                        }
                        break;
                case ZEND_JMP:
@@ -59189,17 +59013,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 3000;
+                               spec = 2994;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 2995 | SPEC_RULE_OP1;
+                               spec = 2989 | 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 = 3002 | SPEC_RULE_RETVAL;
+                               spec = 2996 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -59207,17 +59031,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 = 2965 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 2959 | 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 = 3001;
+                               spec = 2995;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 2990 | SPEC_RULE_OP1;
+                               spec = 2984 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 11a369286bc61398a075315553f06bdf65aeff15..277c82b7ebc878b4609a775e590f3df30da5bb09 100755 (executable)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -1216,7 +1216,7 @@ function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno,
                                if ($cold) {
                                        $zend_attributes = " zend_never_inline ZEND_COLD";
                                } else {
-                                       $zend_attributes = "";
+                                       $zend_attributes = " zend_never_inline";
                                }
                                $zend_fastcall = " ZEND_FASTCALL";
                        }

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index a2be1494a3ca17b37479ac22efa92f7062908360..cf2128aa5dd09727fb14926d72b887364e297cc9 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1622,49 +1622,43 @@
        _(2938, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
        _(2939, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
        _(2940, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-       _(2941, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED) \
-       _(2942, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED) \
-       _(2943, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-       _(2944, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-       _(2945, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-       _(2946, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-       _(2947, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED) \
-       _(2948, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED) \
-       _(2949, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-       _(2950, ZEND_POST_INC_LONG_SPEC_CV) \
-       _(2951, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV) \
-       _(2952, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-       _(2953, ZEND_POST_DEC_LONG_SPEC_CV) \
-       _(2954, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV) \
-       _(2955, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(2956, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(2957, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(2959, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(2960, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(2961, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(2962, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(2964, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(2966, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(2967, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(2969, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(2970, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(2941, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+       _(2942, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+       _(2943, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+       _(2944, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+       _(2945, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+       _(2946, ZEND_POST_INC_LONG_SPEC_CV) \
+       _(2947, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+       _(2948, ZEND_POST_DEC_LONG_SPEC_CV) \
+       _(2949, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+       _(2950, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(2951, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(2953, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(2954, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+       _(2955, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(2956, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(2958, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(2960, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(2961, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(2963, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(2964, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(2965, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(2966, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(2968, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(2969, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(2970, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
        _(2971, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2972, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2974, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2975, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(2976, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2977, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2979, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(2985, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(2986, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(2987, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(2989, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(2992, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(2994, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(2997, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(2999, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(3000, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(3001, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(3002, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(3003, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(3003+1, ZEND_NULL)
+       _(2973, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(2979, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+       _(2980, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(2981, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(2983, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(2986, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(2988, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(2991, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(2993, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(2994, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(2995, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(2996, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(2997, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(2997+1, ZEND_NULL)