Reduce over-specialization for quite seldom instructions

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 70b050fd098dd92c672fb249572cd3559ae40347..5a5b8e0ad1a8a6159cbd415692fefd1d5b75c0a0 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -585,6 +585,19 @@ static inline void zend_assign_to_variable_reference(zval *variable_ptr, zval *v
        ZVAL_REF(variable_ptr, ref);
 }
 
+static zend_never_inline zval* zend_assign_to_typed_property_reference(zend_property_info *prop_info, zval *prop, zval *value_ptr)
+{
+       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+               return &EG(uninitialized_zval);
+       }
+       if (Z_ISREF_P(prop)) {
+               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       return prop;
+}
+
 static zend_never_inline ZEND_COLD int zend_wrong_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
 {
        zend_error(E_NOTICE, "Only variables should be assigned by reference");
@@ -2780,6 +2793,78 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
        }
 }
 
+static zend_always_inline void zend_assign_to_property_reference(zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
+{
+       zval variable, *variable_ptr = &variable;
+       void **cache_addr = (prop_op_type == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, container_op_type, prop_ptr, prop_op_type,
+               cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
+
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       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))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
+                       variable_ptr = &EG(uninitialized_zval);
+               }
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (prop_op_type == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       variable_ptr = zend_assign_to_typed_property_reference(prop_info, variable_ptr, value_ptr);
+               } else {
+                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+}
+
+static zend_never_inline void zend_assign_to_property_reference_this_const(zval *container, zval *prop_ptr, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
+{
+       zend_assign_to_property_reference(container, IS_UNUSED, prop_ptr, IS_CONST, value_ptr
+               OPLINE_CC EXECUTE_DATA_CC);
+}
+
+static zend_never_inline void zend_assign_to_property_reference_var_const(zval *container, zval *prop_ptr, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
+{
+       zend_assign_to_property_reference(container, IS_VAR, prop_ptr, IS_CONST, value_ptr
+               OPLINE_CC EXECUTE_DATA_CC);
+}
+
+static zend_never_inline void zend_assign_to_property_reference_this_var(zval *container, zval *prop_ptr, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
+{
+       zend_assign_to_property_reference(container, IS_VAR, prop_ptr, IS_CONST, value_ptr
+               OPLINE_CC EXECUTE_DATA_CC);
+}
+
+static zend_never_inline void zend_assign_to_property_reference_var_var(zval *container, zval *prop_ptr, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC)
+{
+       zend_assign_to_property_reference(container, IS_VAR, prop_ptr, IS_VAR, value_ptr
+               OPLINE_CC EXECUTE_DATA_CC);
+}
+
 static zend_never_inline int zend_fetch_static_property_address_ex(zval **retval, zend_property_info **prop_info, uint32_t cache_slot, int fetch_type OPLINE_DC EXECUTE_DATA_DC) {
        zend_free_op free_op1;
        zend_string *name, *tmp_name;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index aad472f6f25f6bc5d4e8adf906292696d120b049..6f58244e5204beb5e1e497d5bd14c81a0a94e08b 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2601,11 +2601,7 @@ ZEND_VM_HANDLER(200, ZEND_ASSIGN_OBJ_REF, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, C
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -2617,59 +2613,24 @@ ZEND_VM_HANDLER(200, ZEND_ASSIGN_OBJ_REF, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, C
 
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-       cache_addr = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, OP1_TYPE, property, OP2_TYPE, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
 
-       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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (OP2_TYPE == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (OP1_TYPE == IS_UNUSED) {
+                       if (OP2_TYPE == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (OP2_TYPE == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, OP1_TYPE, property, OP2_TYPE, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        FREE_OP1_VAR_PTR();
@@ -2702,22 +2663,10 @@ ZEND_VM_HANDLER(202, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC)
                if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
                        prop = &EG(uninitialized_zval);
                }
+       } else if (UNEXPECTED(prop_info->type)) {
+               prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr);
        } else {
-               do {
-                       if (UNEXPECTED(prop_info->type)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       prop = &EG(uninitialized_zval);
-                                       break;
-                               }
-                               if (Z_ISREF_P(prop)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
-                               }
-                       }
-                       zend_assign_to_variable_reference(prop, value_ptr);
-                       if (prop_info->type) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
-                       }
-               } while (0);
+               zend_assign_to_variable_reference(prop, value_ptr);
        }
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 003dde0aa17fd25dfab723359067789661bcfda9..80c354475bd969d06e0db8687fc27f071fa88cf5 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -824,22 +824,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA
                if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
                        prop = &EG(uninitialized_zval);
                }
+       } else if (UNEXPECTED(prop_info->type)) {
+               prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr);
        } else {
-               do {
-                       if (UNEXPECTED(prop_info->type)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       prop = &EG(uninitialized_zval);
-                                       break;
-                               }
-                               if (Z_ISREF_P(prop)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
-                               }
-                       }
-                       zend_assign_to_variable_reference(prop, value_ptr);
-                       if (prop_info->type) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
-                       }
-               } while (0);
+               zend_assign_to_variable_reference(prop, value_ptr);
        }
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -23249,11 +23237,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_
 {
        USE_OPLINE
        zend_free_op free_op1, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -23265,59 +23249,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -23331,11 +23280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -23347,59 +23292,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -25753,11 +25663,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -25769,59 +25675,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -25835,11 +25706,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -25851,59 +25718,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -29932,11 +29764,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_
 {
        USE_OPLINE
        zend_free_op free_op1, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -29948,59 +29776,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -30014,11 +29807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -30030,59 +29819,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_VAR == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
@@ -31953,11 +31707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CON
 {
        USE_OPLINE
        zend_free_op free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -31969,59 +31719,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CON
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -32034,11 +31749,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CON
 {
        USE_OPLINE
 
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -32050,59 +31761,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CON
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -33890,11 +33566,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP
 {
        USE_OPLINE
        zend_free_op free_op2, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -33906,59 +33578,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op2);
@@ -33971,11 +33608,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -33987,59 +33620,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op2);
@@ -36497,11 +36095,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_
 {
        USE_OPLINE
        zend_free_op free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -36513,59 +36107,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -36578,11 +36137,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_
 {
        USE_OPLINE
 
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -36594,59 +36149,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_UNUSED == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -41651,11 +41171,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_O
 {
        USE_OPLINE
        zend_free_op free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -41667,59 +41183,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_O
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -41732,11 +41213,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_O
 {
        USE_OPLINE
 
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -41748,59 +41225,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_O
 
        property = RT_CONSTANT(opline, opline->op2);
 
-       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CONST == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CONST == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -45511,11 +44953,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_
 {
        USE_OPLINE
        zend_free_op free_op2, free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -45527,59 +44965,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op2);
@@ -45592,11 +44995,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -45608,59 +45007,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
-       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
        zval_ptr_dtor_nogc(free_op2);
@@ -51151,11 +50515,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_D
 {
        USE_OPLINE
        zend_free_op free_op_data;
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -51167,59 +50527,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_D
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }
 
 
@@ -51232,11 +50557,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_D
 {
        USE_OPLINE
 
-       zval *property;
-       zval *container;
-       zval variable, *variable_ptr = &variable;
-       zval *value_ptr;
-       void **cache_addr;
+       zval *property, *container, *value_ptr;
 
        SAVE_OPLINE();
 
@@ -51248,59 +50569,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_D
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
-       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
-
-       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC EXECUTE_DATA_CC);
-       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
-               variable_ptr = Z_INDIRECT_P(variable_ptr);
-       }
-
        value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
 
-       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 (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))) {
-
-               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
-                               variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
-                       variable_ptr = &EG(uninitialized_zval);
-               }
-       } else {
-               zend_property_info *prop_info = NULL;
-
-               if (IS_CV == IS_CONST) {
-                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
-               } else {
-                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
-               }
-
-               do {
-                       if (UNEXPECTED(prop_info)) {
-                               if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
-                                       variable_ptr = &EG(uninitialized_zval);
-                                       break;
-                               }
-
-                               if (Z_ISREF_P(variable_ptr)) {
-                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
-                               }
+       if (ZEND_VM_SPEC) {
+               if (IS_CV == IS_UNUSED) {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-                       zend_assign_to_variable_reference(variable_ptr, value_ptr);
-                       if (prop_info) {
-                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               } else {
+                       if (IS_CV == IS_CONST) {
+                               zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
+                       } else {
+                               zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
                        }
-               } while (0);
-       }
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+               }
+       } else {
+               zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
        }