Use special type IS_ERROR instread of EG(error_zval). (we still need EG(error_zval...

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index f6783289890f1f82475f2fef1ee67070f9799040..f82ac83e4fbbe54dde464cb11b3e4ff95d0f18ad 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1106,7 +1106,7 @@ static zend_always_inline void zend_assign_to_object(zval *retval, zval *object,
 
        if (object_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                do {
-                       if (object_op_type == IS_VAR && UNEXPECTED(object == &EG(error_zval))) {
+                       if (object_op_type == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_ERROR)) {
                                if (retval) {
                                        ZVAL_NULL(retval);
                                }
@@ -1649,7 +1649,7 @@ str_index:
                        default:
                                zend_error(E_WARNING, "Illegal offset type");
                                retval = (type == BP_VAR_W || type == BP_VAR_RW) ?
-                                       &EG(error_zval) : &EG(uninitialized_zval);
+                                       NULL : &EG(uninitialized_zval);
                }
        }
        return retval;
@@ -1832,10 +1832,15 @@ fetch_from_array:
                        retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
                        if (UNEXPECTED(retval == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               retval = &EG(error_zval);
+                               ZVAL_ERROR(result);
+                               return;
                        }
                } else {
                        retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type);
+                       if (UNEXPECTED(!retval)) {
+                               ZVAL_ERROR(result);
+                               return;
+                       }
                }
                ZVAL_INDIRECT(result, retval);
                return;
@@ -1860,11 +1865,11 @@ convert_to_array:
                        zend_check_string_offset(dim, type);
                        zend_wrong_string_offset();
                }
-               ZVAL_INDIRECT(result, &EG(error_zval));
+               ZVAL_ERROR(result);
        } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
                if (!Z_OBJ_HT_P(container)->read_dimension) {
                        zend_throw_error(NULL, "Cannot use object as array");
-                       retval = &EG(error_zval);
+                       ZVAL_ERROR(result);
                } else {
                        retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result);
 
@@ -1897,25 +1902,25 @@ convert_to_array:
                                        ZVAL_INDIRECT(result, retval);
                                }
                        } else {
-                               ZVAL_INDIRECT(result, &EG(error_zval));
+                               ZVAL_ERROR(result);
                        }
                }
        } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
-               if (UNEXPECTED(container == &EG(error_zval))) {
-                       ZVAL_INDIRECT(result, &EG(error_zval));
-               } else if (type != BP_VAR_UNSET) {
+               if (type != BP_VAR_UNSET) {
                        goto convert_to_array;
                } else {
                        /* for read-mode only */
                        ZVAL_NULL(result);
                }
+       } else if (EXPECTED(Z_TYPE_P(container) == IS_ERROR)) {
+               ZVAL_ERROR(result);
        } else {
                if (type == BP_VAR_UNSET) {
                        zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
                        ZVAL_NULL(result);
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
-                       ZVAL_INDIRECT(result, &EG(error_zval));
+                       ZVAL_ERROR(result);
                }
        }
 }
@@ -2044,8 +2049,8 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
 {
     if (container_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
                do {
-                       if (container_op_type == IS_VAR && UNEXPECTED(container == &EG(error_zval))) {
-                               ZVAL_INDIRECT(result, &EG(error_zval));
+                       if (container_op_type == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_ERROR)) {
+                               ZVAL_ERROR(result);
                                return;
                        }
 
@@ -2064,7 +2069,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
                                object_init(container);
                        } else {
                                zend_error(E_WARNING, "Attempt to modify property of non-object");
-                               ZVAL_INDIRECT(result, &EG(error_zval));
+                               ZVAL_ERROR(result);
                                return;
                        }
                } while (0);
@@ -2107,7 +2112,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
                                }
                        } else {
                                zend_throw_error(NULL, "Cannot access undefined property for object with overloaded property access");
-                               ZVAL_INDIRECT(result, &EG(error_zval));
+                               ZVAL_ERROR(result);
                        }
                } else {
                        ZVAL_INDIRECT(result, ptr);
@@ -2121,7 +2126,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
                }
        } else {
                zend_error(E_WARNING, "This object doesn't support property references");
-               ZVAL_INDIRECT(result, &EG(error_zval));
+               ZVAL_ERROR(result);
        }
 }
 

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 0c6f0377dab343d7c1f907723a51c2906f553235..cf92d4807c6120a97a4f6a99e37b0010e357c9d2 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -130,7 +130,7 @@ void init_executor(void) /* {{{ */
        zend_init_fpu();
 
        ZVAL_NULL(&EG(uninitialized_zval));
-       ZVAL_NULL(&EG(error_zval));
+       ZVAL_ERROR(&EG(error_zval));
 /* destroys stack frame, therefore makes core dumps worthless */
 #if 0&&ZEND_DEBUG
        original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index da0c985481f12a4746bdb8c3f5a10990b607886f..ebd9e0e3ef1e004e3660521a6fa4e4f92c7d167a 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -324,6 +324,7 @@ struct _zend_ast_ref {
 /* internal types */
 #define IS_INDIRECT                    15
 #define IS_PTR                                         17
+#define IS_ERROR                                       19
 
 static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
        return pz->u1.v.type;
@@ -781,6 +782,10 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
                Z_TYPE_INFO_P(z) = IS_PTR;                                                              \
        } while (0)
 
+#define ZVAL_ERROR(z) do {                             \
+               Z_TYPE_INFO_P(z) = IS_ERROR;    \
+       } while (0)
+
 #define Z_REFCOUNT_P(pz)                       zval_refcount_p(pz)
 #define Z_SET_REFCOUNT_P(pz, rc)       zval_set_refcount_p(pz, rc)
 #define Z_ADDREF_P(pz)                         zval_addref_p(pz)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index dfd8d1b2b551ce56c1d99d51b588070a0f449a5c..3ae30a8cfd08386122c620dd3ac4ad177c5a5ba3 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -789,14 +789,14 @@ ZEND_VM_HELPER(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|UNU
 
                zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -825,7 +825,7 @@ ZEND_VM_HELPER(zend_binary_assign_op_helper, VAR|CV, CONST|TMPVAR|CV, binary_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(var_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -1247,7 +1247,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -1287,7 +1287,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -1325,7 +1325,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -1358,7 +1358,7 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -2139,7 +2139,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -2148,7 +2148,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                        FREE_OP2();
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -2197,10 +2197,9 @@ ZEND_VM_C_LABEL(assign_dim_convert_to_array):
                                ZEND_VM_C_GOTO(try_assign_dim_array);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               ZEND_VM_C_GOTO(assign_dim_clean);
-                       }
                        ZEND_VM_C_GOTO(assign_dim_convert_to_array);
+               } else if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       ZEND_VM_C_GOTO(assign_dim_clean);
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 ZEND_VM_C_LABEL(assign_dim_clean):
@@ -2229,7 +2228,7 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
        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(variable_ptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
                FREE_OP2();
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -2258,7 +2257,8 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
 
        if (OP1_TYPE == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
-           UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_REFERENCE) &&
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_ERROR)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
                FREE_OP2_VAR_PTR();
                HANDLE_EXCEPTION();
@@ -2279,8 +2279,8 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
        }
 
        variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
-       if ((OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
-           (OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+       if ((OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) ||
+           (OP2_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_ERROR))) {
                variable_ptr = &EG(uninitialized_zval);
        } else {
                zend_assign_to_variable_reference(variable_ptr, value_ptr);
@@ -4268,7 +4268,7 @@ 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(varptr == &EG(error_zval))) {
+       if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_ERROR)) {
                ZVAL_NEW_REF(arg, &EG(uninitialized_zval));
                ZEND_VM_NEXT_OPCODE();
        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 934e960b9b43635466bf79c8efd9f1357969eae1..31acf1d28ce0ec74d5aa974732d7f6d82847970c 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -14608,7 +14608,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -14648,7 +14648,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -14686,7 +14686,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -14719,7 +14719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -15016,7 +15016,7 @@ 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, &free_op1);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       if (IS_VAR == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_ERROR)) {
                ZVAL_NEW_REF(arg, &EG(uninitialized_zval));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -16303,14 +16303,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -16338,7 +16338,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_V
        value = EX_CONSTANT(opline->op2);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -17063,7 +17063,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = EX_CONSTANT(opline->op2);
@@ -17072,7 +17072,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -17121,10 +17121,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -17153,7 +17152,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(
        value = EX_CONSTANT(opline->op2);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -17832,7 +17831,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZE
        value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
                zval_ptr_dtor_nogc(free_op2);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -18032,7 +18031,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZE
        value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
                zval_ptr_dtor_nogc(free_op2);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -18061,7 +18060,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE
 
        if (IS_VAR == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
-           UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_REFERENCE) &&
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_ERROR)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
                if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
                HANDLE_EXCEPTION();
@@ -18082,8 +18082,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE
        }
 
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-       if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
-           (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+       if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) ||
+           (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_ERROR))) {
                variable_ptr = &EG(uninitialized_zval);
        } else {
                zend_assign_to_variable_reference(variable_ptr, value_ptr);
@@ -18267,14 +18267,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -18624,7 +18624,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = NULL;
@@ -18633,7 +18633,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -18682,10 +18682,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -19303,14 +19302,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -19338,7 +19337,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_V
        value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -20063,7 +20062,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
@@ -20072,7 +20071,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -20121,10 +20120,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -20153,7 +20151,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEN
        value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -20182,7 +20180,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
 
        if (IS_VAR == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
-           UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_REFERENCE) &&
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_ERROR)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
 
                HANDLE_EXCEPTION();
@@ -20203,8 +20202,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
        }
 
        variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-       if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
-           (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+       if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) ||
+           (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_ERROR))) {
                variable_ptr = &EG(uninitialized_zval);
        } else {
                zend_assign_to_variable_reference(variable_ptr, value_ptr);
@@ -20842,14 +20841,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -20878,7 +20877,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_V
        value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
        var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-       if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -21607,7 +21606,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
@@ -21616,7 +21615,7 @@ try_assign_dim_array:
                        zval_ptr_dtor_nogc(free_op2);
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -21665,10 +21664,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -22337,14 +22335,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -24229,14 +24227,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -24945,14 +24943,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -26499,14 +26497,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -27890,7 +27888,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_O
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -27929,7 +27927,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_O
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -27966,7 +27964,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -27998,7 +27996,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_
                ZEND_VM_NEXT_OPCODE();
        }
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                ZVAL_NULL(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -28474,7 +28472,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_
        varptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var);
 
        arg = ZEND_CALL_VAR(EX(call), opline->result.var);
-       if (IS_CV == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_ERROR)) {
                ZVAL_NEW_REF(arg, &EG(uninitialized_zval));
                ZEND_VM_NEXT_OPCODE();
        }
@@ -30220,14 +30218,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -30255,7 +30253,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_C
        value = EX_CONSTANT(opline->op2);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -31263,7 +31261,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = EX_CONSTANT(opline->op2);
@@ -31272,7 +31270,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -31321,10 +31319,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -31353,7 +31350,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(Z
        value = EX_CONSTANT(opline->op2);
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -32577,7 +32574,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEN
        value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
                zval_ptr_dtor_nogc(free_op2);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -32915,7 +32912,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEN
        value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
                zval_ptr_dtor_nogc(free_op2);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -32944,7 +32941,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
 
        if (IS_CV == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
-           UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_REFERENCE) &&
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_ERROR)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
                if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
                HANDLE_EXCEPTION();
@@ -32965,8 +32963,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
        }
 
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-       if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
-           (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+       if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) ||
+           (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_ERROR))) {
                variable_ptr = &EG(uninitialized_zval);
        } else {
                zend_assign_to_variable_reference(variable_ptr, value_ptr);
@@ -33340,14 +33338,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -33959,7 +33957,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = NULL;
@@ -33968,7 +33966,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -34017,10 +34015,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -35384,14 +35381,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -35419,7 +35416,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_C
        value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -36244,7 +36241,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
@@ -36253,7 +36250,7 @@ try_assign_dim_array:
 
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -36302,10 +36299,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:
@@ -36334,7 +36330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND
        value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) {
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
@@ -36363,7 +36359,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
 
        if (IS_CV == IS_VAR &&
            UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
-           UNEXPECTED(!Z_ISREF_P(EX_VAR(opline->op1.var)))) {
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_REFERENCE) &&
+           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_ERROR)) {
                zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
 
                HANDLE_EXCEPTION();
@@ -36384,8 +36381,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
        }
 
        variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
-       if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
-           (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+       if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_ERROR)) ||
+           (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_ERROR))) {
                variable_ptr = &EG(uninitialized_zval);
        } else {
                zend_assign_to_variable_reference(variable_ptr, value_ptr);
@@ -37916,14 +37913,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-               var_ptr = Z_INDIRECT(rv);
 
-               if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(Z_TYPE(rv) == IS_ERROR)) {
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        }
                } else {
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       var_ptr = Z_INDIRECT(rv);
                        ZVAL_DEREF(var_ptr);
                        SEPARATE_ZVAL_NOREF(var_ptr);
 
@@ -37952,7 +37949,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_C
        value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
        var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
 
-       if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+       if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_ERROR)) {
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
@@ -38782,7 +38779,7 @@ try_assign_dim_array:
                        variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-                               variable_ptr = &EG(error_zval);
+                               variable_ptr = NULL;
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
@@ -38791,7 +38788,7 @@ try_assign_dim_array:
                        zval_ptr_dtor_nogc(free_op2);
                }
                value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
-               if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+               if (UNEXPECTED(variable_ptr == NULL)) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -38840,10 +38837,9 @@ assign_dim_convert_to_array:
                                goto try_assign_dim_array;
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
-                       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == &EG(error_zval))) {
-                               goto assign_dim_clean;
-                       }
                        goto assign_dim_convert_to_array;
+               } else if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_ERROR)) {
+                       goto assign_dim_clean;
                } else {
                        zend_error(E_WARNING, "Cannot use a scalar value as an array");
 assign_dim_clean:

diff --git a/ext/standard/incomplete_class.c b/ext/standard/incomplete_class.c
index 887f209299cf15d84cd6ac273b075cfbd0562336..d327602e75363e61ba85466c37ec01361509d80b 100644 (file)
--- a/ext/standard/incomplete_class.c
+++ b/ext/standard/incomplete_class.c
@@ -54,7 +54,8 @@ static zval *incomplete_class_get_property(zval *object, zval *member, int type,
        incomplete_class_message(object, E_NOTICE);
 
        if (type == BP_VAR_W || type == BP_VAR_RW) {
-               return &EG(error_zval);
+               ZVAL_ERROR(rv);
+               return rv;
        } else {
                return &EG(uninitialized_zval);
        }