Remove most uses of the ERROR type

It is now only used to signal exceptions for property reads. ERROR
zvals are never returned back to the VM anymore, so there's no
need to check for them when receiving a VAR.

Also return MAY_BE_ERROR, as ERROR is now no longer relevant for
inference.

diff --git a/Zend/tests/bug36303.phpt b/Zend/tests/bug36303.phpt
deleted file mode 100644 (file)
index 80f2aa1..0000000
--- a/Zend/tests/bug36303.phpt
+++ /dev/null
@@ -1,16 +0,0 @@
---TEST--
-Bug #36303 (foreach on error_zval produces segfault)
---XFAIL--
-TODO: ERROR zval still possible?
---FILE--
-<?php
-$x = [];
-foreach ($x[[]] as &$v) {
-}
-echo "ok\n";
-?>
---EXPECTF--
-Warning: Illegal offset type in %s on line %d
-
-Warning: Invalid argument supplied for foreach() in %s on line %d
-ok

diff --git a/Zend/tests/bug52237.phpt b/Zend/tests/bug52237.phpt
deleted file mode 100644 (file)
index 3e1ac04..0000000
--- a/Zend/tests/bug52237.phpt
+++ /dev/null
@@ -1,13 +0,0 @@
---TEST--
-Bug #52237 (Crash when passing the reference of the property of a non-object)
---XFAIL--
-TODO: ERROR zval still possible?
---FILE--
-<?php
-$data = [];
-preg_match('//', '', $data[[]]);
-var_dump(count($data));
-?>
---EXPECTF--
-Warning: Illegal offset type in %s on line %d
-int(0)

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 0c6a1371f6b26cf3351ec18672a2ef8025d9bd13..d180a836012236086ba5c6cb7d91a7732ddc9ff2 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -617,30 +617,27 @@ static zend_never_inline zend_bool zend_verify_ref_array_assignable(zend_referen
 /* this should modify object only if it's empty */
 static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_throw_non_object_error(zval *object, zval *property OPLINE_DC EXECUTE_DATA_DC)
 {
-       /* TODO: What about the ERROR case? */
-       if (EXPECTED(!Z_ISERROR_P(object))) {
-               zend_string *tmp_property_name;
-               zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name);
-
-               if (opline->opcode == ZEND_PRE_INC_OBJ
-                || opline->opcode == ZEND_PRE_DEC_OBJ
-                || opline->opcode == ZEND_POST_INC_OBJ
-                || opline->opcode == ZEND_POST_DEC_OBJ) {
-                       zend_throw_error(NULL,
-                               "Attempt to increment/decrement property '%s' of non-object",
-                               ZSTR_VAL(property_name));
-               } else if (opline->opcode == ZEND_FETCH_OBJ_W
-                               || opline->opcode == ZEND_FETCH_OBJ_RW
-                               || opline->opcode == ZEND_FETCH_OBJ_FUNC_ARG
-                               || opline->opcode == ZEND_ASSIGN_OBJ_REF) {
-                       zend_throw_error(NULL,
-                               "Attempt to modify property '%s' of non-object", ZSTR_VAL(property_name));
-               } else {
-                       zend_throw_error(NULL,
-                               "Attempt to assign property '%s' of non-object", ZSTR_VAL(property_name));
-               }
-               zend_tmp_string_release(tmp_property_name);
+       zend_string *tmp_property_name;
+       zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name);
+
+       if (opline->opcode == ZEND_PRE_INC_OBJ
+        || opline->opcode == ZEND_PRE_DEC_OBJ
+        || opline->opcode == ZEND_POST_INC_OBJ
+        || opline->opcode == ZEND_POST_DEC_OBJ) {
+               zend_throw_error(NULL,
+                       "Attempt to increment/decrement property '%s' of non-object",
+                       ZSTR_VAL(property_name));
+       } else if (opline->opcode == ZEND_FETCH_OBJ_W
+                       || opline->opcode == ZEND_FETCH_OBJ_RW
+                       || opline->opcode == ZEND_FETCH_OBJ_FUNC_ARG
+                       || opline->opcode == ZEND_ASSIGN_OBJ_REF) {
+               zend_throw_error(NULL,
+                       "Attempt to modify property '%s' of non-object", ZSTR_VAL(property_name));
+       } else {
+               zend_throw_error(NULL,
+                       "Attempt to assign property '%s' of non-object", ZSTR_VAL(property_name));
        }
+       zend_tmp_string_release(tmp_property_name);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -1914,7 +1911,7 @@ static ZEND_COLD void zend_binary_assign_op_dim_slow(zval *container, zval *dim
                        zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC);
                        zend_wrong_string_offset(EXECUTE_DATA_C);
                }
-       } else if (EXPECTED(!Z_ISERROR_P(container))) {
+       } else {
                zend_use_scalar_as_array();
        }
        FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
@@ -2079,13 +2076,13 @@ fetch_from_array:
                        retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
                        if (UNEXPECTED(retval == NULL)) {
                                zend_cannot_add_element();
-                               ZVAL_ERROR(result);
+                               ZVAL_UNDEF(result);
                                return;
                        }
                } else {
                        retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type EXECUTE_DATA_CC);
                        if (UNEXPECTED(!retval)) {
-                               ZVAL_ERROR(result);
+                               ZVAL_UNDEF(result);
                                return;
                        }
                }
@@ -2100,7 +2097,7 @@ fetch_from_array:
                        if (type != BP_VAR_UNSET) {
                                if (ZEND_REF_HAS_TYPE_SOURCES(ref)) {
                                        if (UNEXPECTED(!zend_verify_ref_array_assignable(ref))) {
-                                               ZVAL_ERROR(result);
+                                               ZVAL_UNDEF(result);
                                                return;
                                        }
                                }
@@ -2118,7 +2115,7 @@ fetch_from_array:
                        zend_check_string_offset(dim, type EXECUTE_DATA_CC);
                        zend_wrong_string_offset(EXECUTE_DATA_C);
                }
-               ZVAL_ERROR(result);
+               ZVAL_UNDEF(result);
        } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
                if (ZEND_CONST_COND(dim_type == IS_CV, dim != NULL) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) {
                        dim = ZVAL_UNDEFINED_OP2();
@@ -2150,7 +2147,8 @@ fetch_from_array:
                                ZVAL_INDIRECT(result, retval);
                        }
                } else {
-                       ZVAL_ERROR(result);
+                       ZEND_ASSERT(EG(exception) && "read_dimension() returned NULL without exception");
+                       ZVAL_UNDEF(result);
                }
        } else {
                if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
@@ -2168,15 +2166,13 @@ return_null:
                                }
                                ZVAL_NULL(result);
                        }
-               } else if (EXPECTED(Z_ISERROR_P(container))) {
-                       ZVAL_ERROR(result);
                } else {
                        if (type == BP_VAR_UNSET) {
                                zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
-                               ZVAL_NULL(result);
+                               ZVAL_UNDEF(result);
                        } else {
                                zend_use_scalar_as_array();
-                               ZVAL_ERROR(result);
+                               ZVAL_UNDEF(result);
                        }
                }
        }
@@ -2698,13 +2694,12 @@ static zend_always_inline void zend_assign_to_property_reference(zval *container
                variable_ptr = Z_INDIRECT_P(variable_ptr);
        }
 
+       /* variable_ptr may be ERROR if fetching the property threw an exception. */
        if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
                variable_ptr = &EG(uninitialized_zval);
        } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (/*OP_DATA_TYPE == IS_VAR &&*/ UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (/*OP_DATA_TYPE == IS_VAR &&*/
                   (opline->extended_value & ZEND_RETURNS_FUNCTION) &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {

diff --git a/Zend/zend_type_info.h b/Zend/zend_type_info.h
index c991fd5db5994a9583ebf66fbde9ae55324e92ec..9479d5aad2c03d2add15cca54e830f72dc044189 100644 (file)
--- a/Zend/zend_type_info.h
+++ b/Zend/zend_type_info.h
@@ -57,7 +57,7 @@
 #define MAY_BE_ARRAY_KEY_STRING     (1<<26)
 #define MAY_BE_ARRAY_KEY_ANY        (MAY_BE_ARRAY_KEY_LONG | MAY_BE_ARRAY_KEY_STRING)
 
-#define MAY_BE_ERROR                (1<<27)
+/* Bit 27 unused  */
 #define MAY_BE_CLASS                (1<<28)
 
 #endif /* ZEND_TYPE_INFO_H */

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 3a031f6aa90015948fe250a24364e705dd2c197a..3e83cccdf5190caed1919918a48aa58ccedb9598 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1279,26 +1279,20 @@ ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP)
        value = GET_OP2_ZVAL_PTR(BP_VAR_R);
        var_ptr = GET_OP1_ZVAL_PTR_PTR(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));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        FREE_OP2();
@@ -1520,13 +1514,6 @@ ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY)
 
        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));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        SAVE_OPLINE();
        if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -1578,13 +1565,6 @@ ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY)
 
        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));
-               }
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        SAVE_OPLINE();
        if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);             
@@ -1637,11 +1617,6 @@ ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY)
 
        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();
-       }
-
        SAVE_OPLINE();
        if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -1690,11 +1665,6 @@ ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY)
 
        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();
-       }
-
        SAVE_OPLINE();
        if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -2718,9 +2688,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                                ZEND_VM_C_GOTO(try_assign_dim_array);
                        }
                } else {
-                       if (OP1_TYPE != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 ZEND_VM_C_LABEL(assign_dim_error):
                        FREE_UNFETCHED_OP_DATA();
@@ -2747,19 +2715,12 @@ ZEND_VM_HANDLER(22, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV, SPEC(RETVAL))
        value = GET_OP2_ZVAL_PTR(BP_VAR_R);
        variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               FREE_OP2();
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               FREE_OP1_VAR_PTR();
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       FREE_OP1_VAR_PTR();
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -2774,15 +2735,11 @@ ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
        value_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
        variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
-       } else if (OP1_TYPE == IS_VAR &&
+       if (OP1_TYPE == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
                zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (OP2_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (OP2_TYPE == IS_VAR &&
                   opline->extended_value == ZEND_RETURNS_FUNCTION &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {
@@ -2861,9 +2818,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC)
 
        value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
 
-       if (OP_DATA_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               prop = &EG(uninitialized_zval);
-       } else if (OP_DATA_TYPE == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+       if (OP_DATA_TYPE == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
                if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
                        prop = &EG(uninitialized_zval);
                }
@@ -4789,12 +4744,6 @@ ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM)
        varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(varptr))) {
-               ZVAL_NEW_EMPTY_REF(arg);
-               ZVAL_NULL(Z_REFVAL_P(arg));
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (Z_ISREF_P(varptr)) {
                Z_ADDREF_P(varptr);
        } else {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 249c0547230c594229527ffcfd4db8308a8c9def..45f2986be44148c54cd0583890a10275dcd25217 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1102,9 +1102,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA
 
        value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, BP_VAR_W);
 
-       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               prop = &EG(uninitialized_zval);
-       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+       if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
                if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
                        prop = &EG(uninitialized_zval);
                }
@@ -20241,13 +20239,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_help
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       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);
@@ -20317,13 +20308,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_help
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       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);
@@ -20394,11 +20378,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_hel
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var 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();
-       }
-
        SAVE_OPLINE();
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -20447,11 +20426,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_hel
 
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var 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();
-       }
-
        SAVE_OPLINE();
        if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -20853,12 +20827,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND
        varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(varptr))) {
-               ZVAL_NEW_EMPTY_REF(arg);
-               ZVAL_NULL(Z_REFVAL_P(arg));
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (Z_ISREF_P(varptr)) {
                Z_ADDREF_P(varptr);
        } else {
@@ -22092,26 +22060,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDL
        value = RT_CONSTANT(opline, opline->op2);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
@@ -23104,9 +23066,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
 
@@ -23220,9 +23180,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -23336,9 +23294,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -23451,9 +23407,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
 
@@ -23480,19 +23434,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
        value = RT_CONSTANT(opline, opline->op2);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -23507,19 +23454,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
        value = RT_CONSTANT(opline, opline->op2);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -24438,26 +24378,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HAND
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
@@ -25454,9 +25388,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -25570,9 +25502,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -25686,9 +25616,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -25801,9 +25729,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -26336,19 +26262,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNU
        value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -26363,19 +26282,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USE
        value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -26562,19 +26474,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNU
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -26589,19 +26494,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USE
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -26616,15 +26514,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE
        value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_VAR == IS_VAR &&
+       if (IS_VAR == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
                zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (IS_VAR == IS_VAR &&
                   opline->extended_value == ZEND_RETURNS_FUNCTION &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {
@@ -27011,9 +26905,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
 
@@ -27127,9 +27019,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -27243,9 +27133,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -27358,9 +27246,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
 
@@ -28145,26 +28031,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
@@ -29157,9 +29037,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -29273,9 +29151,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -29389,9 +29265,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -29504,9 +29378,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -29533,19 +29405,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUS
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -29560,19 +29425,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
+       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -29587,15 +29445,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
        value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_VAR == IS_VAR &&
+       if (IS_VAR == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
                zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (IS_CV == IS_VAR &&
                   opline->extended_value == ZEND_RETURNS_FUNCTION &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {
@@ -36923,13 +36777,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_help
 
        var_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       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);
@@ -36998,13 +36845,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_help
 
        var_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       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);
@@ -37074,11 +36914,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_hel
 
        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();
-       }
-
        SAVE_OPLINE();
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -37126,11 +36961,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_hel
 
        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();
-       }
-
        SAVE_OPLINE();
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
                ZVAL_NULL(var_ptr);
@@ -37633,12 +37463,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_
        varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(varptr))) {
-               ZVAL_NEW_EMPTY_REF(arg);
-               ZVAL_NULL(Z_REFVAL_P(arg));
-               ZEND_VM_NEXT_OPCODE();
-       }
-
        if (Z_ISREF_P(varptr)) {
                Z_ADDREF_P(varptr);
        } else {
@@ -39392,26 +39216,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLE
        value = RT_CONSTANT(opline, opline->op2);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
 
@@ -40677,9 +40495,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
 
@@ -40793,9 +40609,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -40909,9 +40723,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -41024,9 +40836,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = RT_CONSTANT(opline, opline->op2);
 assign_dim_error:
 
@@ -41053,20 +40863,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UN
        value = RT_CONSTANT(opline, opline->op2);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -41080,20 +40883,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_US
        value = RT_CONSTANT(opline, opline->op2);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -42977,26 +42773,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDL
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
@@ -44260,9 +44050,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -44376,9 +44164,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -44492,9 +44278,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -44607,9 +44391,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -45448,20 +45230,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUS
        value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -45475,20 +45250,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED
        value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -45673,20 +45441,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUS
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -45700,20 +45461,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED
        value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -45727,15 +45481,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
        value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_CV == IS_VAR &&
+       if (IS_CV == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
                zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (IS_VAR == IS_VAR &&
                   opline->extended_value == ZEND_RETURNS_FUNCTION &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {
@@ -46293,9 +46043,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
 
@@ -46409,9 +46157,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -46525,9 +46271,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -46640,9 +46384,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = NULL;
 assign_dim_error:
 
@@ -48121,26 +47863,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(Z
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(var_ptr))) {
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               do {
-                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
-                               zend_reference *ref = Z_REF_P(var_ptr);
-                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
-                                       zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
-                                       break;
-                               }
-                               var_ptr = Z_REFVAL_P(var_ptr);
+       do {
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
+                               break;
                        }
-                       zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
-               } while (0);
-
-               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
                }
+               zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
+       } while (0);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
        }
 
 
@@ -49401,9 +49137,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -49517,9 +49251,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -49633,9 +49365,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
                        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
@@ -49748,9 +49478,7 @@ try_assign_dim_array:
                                goto try_assign_dim_array;
                        }
                } else {
-                       if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                               zend_use_scalar_as_array();
-                       }
+                       zend_use_scalar_as_array();
                        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 assign_dim_error:
 
@@ -49777,20 +49505,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSE
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(0)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(0)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(0)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -49804,20 +49525,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-
-               if (UNEXPECTED(1)) {
-                       ZVAL_NULL(EX_VAR(opline->result.var));
-               }
-       } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
-               if (UNEXPECTED(1)) {
-                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-               }
-
-               /* zend_assign_to_variable() always takes care of op2, never free it! */
+       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
+       if (UNEXPECTED(1)) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
        }
 
+       /* zend_assign_to_variable() always takes care of op2, never free it! */
+
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -49831,15 +49545,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
        value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
        variable_ptr = EX_VAR(opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_CV == IS_VAR &&
+       if (IS_CV == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
                zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                variable_ptr = &EG(uninitialized_zval);
-       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
-               variable_ptr = &EG(uninitialized_zval);
        } else if (IS_CV == IS_VAR &&
                   opline->extended_value == ZEND_RETURNS_FUNCTION &&
                           UNEXPECTED(!Z_ISREF_P(value_ptr))) {

diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
index 34666f1711ac46fb116cd7f3f4508b3e7e264162..6fa3b920cd5a5ce380a639c3d0de61b92ae4bb09 100644 (file)
--- a/ext/dom/php_dom.c
+++ b/ext/dom/php_dom.c
@@ -1450,6 +1450,7 @@ static zval *dom_nodelist_read_dimension(zend_object *object, zval *offset, int
        zval offset_copy;
 
        if (!offset) {
+               zend_throw_error(NULL, "Cannot access node list without offset");
                return NULL;
        }
 

diff --git a/ext/dom/tests/bug67949.phpt b/ext/dom/tests/bug67949.phpt
index dd27352e6c4535e29b3f177d6cc3d90cad51e3db..304c3a91ee3b50e281d05e738c99277032b44e5c 100644 (file)
--- a/ext/dom/tests/bug67949.phpt
+++ b/ext/dom/tests/bug67949.phpt
@@ -42,7 +42,11 @@ var_dump(isset($nodes[$offset]), $nodes[$offset]->textContent);
 var_dump($offset);
 
 echo "testing read_dimension with null offset\n";
-var_dump($nodes[][] = 1);
+try {
+    var_dump($nodes[][] = 1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
 
 echo "testing attribute access\n";
 $anchor = $doc->getElementsByTagName('a')[0];
@@ -82,7 +86,7 @@ bool(true)
 string(4) "data"
 string(4) "test"
 testing read_dimension with null offset
-NULL
+Cannot access node list without offset
 testing attribute access
 string(4) "href"
 ==DONE==

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 2e9181c0a51c941e206d3f2a66b71038cfc55bb8..d10e7f989e2dbe5a07346ae12ff4c658191d4f36 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -311,10 +311,6 @@ static void zend_dump_type_info(uint32_t info, zend_class_entry *ce, int is_inst
                        fprintf(stderr, "resource");
                }
        }
-       if (info & MAY_BE_ERROR) {
-               if (first) first = 0; else fprintf(stderr, ", ");
-               fprintf(stderr, "error");
-       }
 //TODO: this is useful only for JIT???
        if (info & MAY_BE_IN_REG) {
                if (first) first = 0; else fprintf(stderr, ", ");

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 6f40388917488374a76bbce7da93b8e9f8eafc9f..c16652b8b614599d3cdd0ac7034f0125223e5a82 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2065,16 +2065,10 @@ uint32_t zend_array_element_type(uint32_t t1, int write, int insert)
        }
        if (t1 & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_FALSE)) {
                tmp |= MAY_BE_NULL;
-               if (t1 & MAY_BE_ERROR) {
-                       if (write) {
-                               tmp |= MAY_BE_ERROR;
-                       }
-               }
        }
        if (t1 & (MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_RESOURCE)) {
-               tmp |= MAY_BE_NULL;
-               if (write) {
-                       tmp |= MAY_BE_ERROR;
+               if (!write) {
+                       tmp |= MAY_BE_NULL;
                }
        }
        return tmp;
@@ -2425,8 +2419,8 @@ static int zend_update_type_info(const zend_op_array *op_array,
        /* If one of the operands cannot have any type, this means the operand derives from
         * unreachable code. Propagate the empty result early, so that that the following
         * code may assume that operands have at least one type. */
-       if (!(t1 & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_CLASS|MAY_BE_ERROR))
-               || !(t2 & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_CLASS|MAY_BE_ERROR))) {
+       if (!(t1 & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_CLASS))
+               || !(t2 & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_CLASS))) {
                tmp = 0;
                if (ssa_ops[i].result_def >= 0) {
                        UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
@@ -2717,9 +2711,6 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                        tmp |= MAY_BE_LONG;
                                }
                        } else {
-                               if (t1 & MAY_BE_ERROR) {
-                                       tmp |= MAY_BE_NULL;
-                               }
                                if (t1 & (MAY_BE_UNDEF | MAY_BE_NULL)) {
                                        if (opline->opcode == ZEND_PRE_INC) {
                                                tmp |= MAY_BE_LONG;
@@ -2752,7 +2743,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                if (t1 & (MAY_BE_RC1|MAY_BE_RCN)) {
                                        tmp |= MAY_BE_RC1|MAY_BE_RCN;
                                }
-                               tmp |= t1 & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_REF|MAY_BE_RCN);
+                               tmp |= t1 & ~(MAY_BE_UNDEF|MAY_BE_REF|MAY_BE_RCN);
                                if (t1 & MAY_BE_UNDEF) {
                                        tmp |= MAY_BE_NULL;
                                }
@@ -2779,9 +2770,6 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                        tmp |= MAY_BE_LONG;
                                }
                        } else {
-                               if (t1 & MAY_BE_ERROR) {
-                                       tmp |= MAY_BE_NULL;
-                               }
                                if (t1 & (MAY_BE_UNDEF | MAY_BE_NULL)) {
                                        if (opline->opcode == ZEND_POST_INC) {
                                                tmp |= MAY_BE_LONG;
@@ -2959,7 +2947,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                        if (opline->op2_type == IS_VAR && opline->extended_value == ZEND_RETURNS_FUNCTION) {
                                tmp = (MAY_BE_REF | MAY_BE_RCN | MAY_BE_RC1 | t2) & ~MAY_BE_UNDEF;
                        } else {
-                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_RC1|MAY_BE_RCN);
+                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_RC1|MAY_BE_RCN);
                        }
                        if (t2 & MAY_BE_UNDEF) {
                                tmp |= MAY_BE_NULL;
@@ -2987,7 +2975,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                        if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION)) {
                                tmp = (MAY_BE_REF | MAY_BE_RCN | MAY_BE_RC1 | t2) & ~MAY_BE_UNDEF;
                        } else {
-                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_RC1|MAY_BE_RCN);
+                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_RC1|MAY_BE_RCN);
                        }
                        if (t2 & MAY_BE_UNDEF) {
                                tmp |= MAY_BE_NULL;
@@ -3484,18 +3472,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                opline->opcode != ZEND_FETCH_LIST_R ? t1 : ((t1 & ~MAY_BE_STRING) | MAY_BE_NULL),
                                opline->result_type == IS_VAR,
                                opline->op2_type == IS_UNUSED);
-                       if (opline->opcode == ZEND_FETCH_DIM_W ||
-                           opline->opcode == ZEND_FETCH_DIM_RW ||
-                           opline->opcode == ZEND_FETCH_DIM_FUNC_ARG ||
-                           opline->opcode == ZEND_FETCH_LIST_W) {
-                               if (t1 & (MAY_BE_ERROR|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_RESOURCE|MAY_BE_OBJECT)) {
-                                       tmp |= MAY_BE_ERROR;
-                               } else if (opline->op2_type == IS_UNUSED) {
-                                       tmp |= MAY_BE_ERROR;
-                               } else if (t2 & (MAY_BE_ARRAY|MAY_BE_OBJECT)) {
-                                       tmp |= MAY_BE_ERROR;
-                               }
-                       } else if (opline->opcode == ZEND_FETCH_DIM_IS && (t1 & MAY_BE_STRING)) {
+                       if (opline->opcode == ZEND_FETCH_DIM_IS && (t1 & MAY_BE_STRING)) {
                                tmp |= MAY_BE_NULL;
                        }
                        UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
@@ -3514,7 +3491,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                tmp = zend_fetch_prop_type(script,
                                        zend_fetch_prop_info(op_array, ssa, opline, i), &ce);
                                if (opline->result_type != IS_TMP_VAR) {
-                                       tmp |= MAY_BE_REF | MAY_BE_ERROR;
+                                       tmp |= MAY_BE_REF;
                                }
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
                                if (ce) {
@@ -3531,7 +3508,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                        tmp = zend_fetch_prop_type(script,
                                zend_fetch_static_prop_info(script, op_array, ssa, opline), &ce);
                        if (opline->result_type != IS_TMP_VAR) {
-                               tmp |= MAY_BE_REF | MAY_BE_ERROR;
+                               tmp |= MAY_BE_REF;
                        }
                        UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
                        if (ce) {

diff --git a/ext/opcache/Optimizer/zend_inference.h b/ext/opcache/Optimizer/zend_inference.h
index 3024583a24a84d43e36c6fbd7f16d7c27b65c2bd..2e5a44d0bed10078474c4f25175e04b16b3a3b0d 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.h
+++ b/ext/opcache/Optimizer/zend_inference.h
@@ -199,7 +199,7 @@ static zend_always_inline uint32_t get_ssa_var_info(const zend_ssa *ssa, int ssa
        if (ssa->var_info && ssa_var_num >= 0) {
                return ssa->var_info[ssa_var_num].type;
        } else {
-               return MAY_BE_UNDEF | MAY_BE_RC1 | MAY_BE_RCN | MAY_BE_REF | MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_ERROR;
+               return MAY_BE_UNDEF | MAY_BE_RC1 | MAY_BE_RCN | MAY_BE_REF | MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
        }
 }
 

diff --git a/ext/opcache/jit/zend_jit_helpers.c b/ext/opcache/jit/zend_jit_helpers.c
index 37de98d7f0656d54d73fcc15a3f957ac2c4ab250..c626a14ad8a4b46a7ac039ec480ffdaf68aad681 100644 (file)
--- a/ext/opcache/jit/zend_jit_helpers.c
+++ b/ext/opcache/jit/zend_jit_helpers.c
@@ -930,9 +930,7 @@ static void ZEND_FASTCALL zend_jit_assign_dim_helper(zval *object_ptr, zval *dim
                        zend_assign_to_string_offset(object_ptr, dim, value, result);
                }
        } else {
-//???          if (OP1_TYPE != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) {
-                       zend_throw_error(NULL, "Cannot use a scalar value as an array");
-//???          }
+               zend_throw_error(NULL, "Cannot use a scalar value as an array");
                if (result) {
                        ZVAL_UNDEF(result);
                }
@@ -977,9 +975,7 @@ static void ZEND_FASTCALL zend_jit_assign_dim_op_helper(zval *container, zval *d
 //???          } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
 //???                  ZEND_VM_C_GOTO(assign_dim_op_convert_to_array);
                } else {
-//???                  if (UNEXPECTED(OP1_TYPE != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) {
-                               zend_throw_error(NULL, "Cannot use a scalar value as an array");
-//???                  }
+                       zend_throw_error(NULL, "Cannot use a scalar value as an array");
 //???                  if (retval) {
 //???                          ZVAL_NULL(retval);
 //???                  }

diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc
index 2ab3424bc6eb693f67589704afbc741987fd45dc..5bda3f59807d0c6cf6bb44104b319cbdd54460ae 100644 (file)
--- a/ext/opcache/jit/zend_jit_x86.dasc
+++ b/ext/opcache/jit/zend_jit_x86.dasc
@@ -7542,37 +7542,6 @@ static int zend_jit_send_ref(dasm_State **Dst, const zend_op *opline, zend_op_ar
                |       // ret = Z_INDIRECT_P(ret);
                |       GET_Z_PTR r0, r0
                |1:
-               if (op1_info & MAY_BE_ERROR) {
-                       if (op1_info & (MAY_BE_ANY|MAY_BE_REF)) {
-                               if (cold) {
-                                       |       IF_NOT_Z_TYPE r0, _IS_ERROR, >1
-                               } else {
-                                       |       IF_Z_TYPE r0, _IS_ERROR, >1
-                                       |.cold_code
-                                       |1:
-                               }
-                       }
-
-                       |       // ZVAL_NEW_EMPTY_REF(arg);
-                       |       EMALLOC sizeof(zend_reference), op_array, opline
-                       |       SET_ZVAL_PTR arg_addr, r0
-                       |       SET_ZVAL_TYPE_INFO arg_addr, IS_REFERENCE_EX
-                       |       mov dword [r0], 1
-                       |       mov dword [r0 + offsetof(zend_reference, gc.u.type_info)], IS_REFERENCE
-                       |       mov aword [r0 + offsetof(zend_reference, sources.ptr)], 0
-                       ref_addr = ZEND_ADDR_MEM_ZVAL(ZREG_R0, 8);
-                       |       // ZVAL_NULL(Z_REFVAL_P(arg));
-                       |       SET_ZVAL_TYPE_INFO ref_addr, IS_NULL
-
-                       if (op1_info & (MAY_BE_ANY|MAY_BE_REF)) {
-                               |       jmp >7
-                               if (cold) {
-                                       |1:
-                               } else {
-                                       |.code
-                               }
-                       }
-               }
        } else if (opline->op1_type == IS_CV) {
                if (op1_info & MAY_BE_UNDEF) {
                        if (op1_info & (MAY_BE_ANY|MAY_BE_REF)) {