IS_CONST operands don't have to be separated. Use reference-counting instead of dupli...

- with opcache all IS_CONST operands are not refcounted (scalars, interned strings or immutable arrays)
- without opcache IS_CONST operands are not shared between processes or threads and may use common reference counters

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 0e0e1966d16b49d8ed7d27f8858628f32d757ea6..c02b27a953804b902bdedd47e0c2831eed3cdbe7 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -5152,10 +5152,8 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSE
                if (OP1_TYPE == IS_TMP_VAR) {
                        /* pass */
                } else if (OP1_TYPE == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (OP1_TYPE == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -5307,11 +5305,9 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE)
                        if (Z_TYPE_P(expr) == opline->extended_value) {
                                ZVAL_COPY_VALUE(result, expr);
                                if (OP1_TYPE == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
-                                               zval_copy_ctor_func(result);
-                                       }
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                                } else if (OP1_TYPE != IS_TMP_VAR) {
-                                       if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+                                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                                }
 
                                FREE_OP1_IF_VAR();
@@ -5325,9 +5321,7 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE)
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
                                                if (OP1_TYPE == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -5343,9 +5337,7 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE)
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_add_new(Z_OBJPROP_P(result), CG(known_strings)[ZEND_STR_SCALAR], expr);
                                                if (OP1_TYPE == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -6729,20 +6721,20 @@ ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, JMP_ADDR)
                value = Z_REFVAL_P(value);
        }
        if (i_zend_is_true(value)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+
+               ZVAL_COPY_VALUE(result, value);
                if (OP1_TYPE == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (OP1_TYPE == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (OP1_TYPE == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -6770,20 +6762,19 @@ ZEND_VM_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR)
        }
 
        if (Z_TYPE_P(value) > IS_NULL) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+               ZVAL_COPY_VALUE(result, value);
                if (OP1_TYPE == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (OP1_TYPE == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (OP1_TYPE == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -6825,8 +6816,8 @@ ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
        } else {
                ZVAL_COPY_VALUE(result, value);
                if (OP1_TYPE == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(result);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
+                               Z_ADDREF_P(result);
                        }
                }
        }
@@ -7321,8 +7312,8 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                                value = GET_OP1_ZVAL_PTR(BP_VAR_R);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (OP1_TYPE == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -7348,8 +7339,8 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                        /* Consts, temporary variables and references need copying */
                        if (OP1_TYPE == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (OP1_TYPE == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -7376,8 +7367,8 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                /* Consts, temporary variables and references need copying */
                if (OP2_TYPE == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (OP2_TYPE == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index c5d802c2e1bd713e021cce3c31a14c54b3e99b4a..8572451a293b70db951021b9ad7d7f8d399e65e0 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -3315,11 +3315,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_O
                        if (Z_TYPE_P(expr) == opline->extended_value) {
                                ZVAL_COPY_VALUE(result, expr);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
-                                               zval_copy_ctor_func(result);
-                                       }
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                                } else if (IS_CONST != IS_TMP_VAR) {
-                                       if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+                                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                                }
 
                                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -3332,9 +3330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_O
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
                                                if (IS_CONST == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -3350,9 +3346,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_O
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_add_new(Z_OBJPROP_P(result), CG(known_strings)[ZEND_STR_SCALAR], expr);
                                                if (IS_CONST == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -3739,20 +3733,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEN
                value = Z_REFVAL_P(value);
        }
        if (i_zend_is_true(value)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+
+               ZVAL_COPY_VALUE(result, value);
                if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_CONST == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_CONST == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -3779,20 +3773,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZE
        }
 
        if (Z_TYPE_P(value) > IS_NULL) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+               ZVAL_COPY_VALUE(result, value);
                if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_CONST == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_CONST == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -3833,8 +3826,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(Z
        } else {
                ZVAL_COPY_VALUE(result, value);
                if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(result);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
+                               Z_ADDREF_P(result);
                        }
                }
        }
@@ -5666,10 +5659,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C
                if (IS_CONST == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CONST == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -6166,8 +6157,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
                                value = EX_CONSTANT(opline->op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -6192,8 +6183,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
                        /* Consts, temporary variables and references need copying */
                        if (IS_CONST == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CONST == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -6220,8 +6211,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
                /* Consts, temporary variables and references need copying */
                if (IS_CONST == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CONST == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -6337,8 +6328,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
                                value = EX_CONSTANT(opline->op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -6363,8 +6354,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_CONST == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CONST == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -6391,8 +6382,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_TMP_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -6788,8 +6779,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
                                value = EX_CONSTANT(opline->op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -6814,8 +6805,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_CONST == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CONST == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -6842,8 +6833,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -7418,10 +7409,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_U
                if (IS_CONST == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CONST == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -7843,8 +7832,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
                                value = EX_CONSTANT(opline->op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -7869,8 +7858,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
                        /* Consts, temporary variables and references need copying */
                        if (IS_CONST == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CONST == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -7897,8 +7886,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
                /* Consts, temporary variables and references need copying */
                if (IS_UNUSED == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_UNUSED == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -9388,10 +9377,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C
                if (IS_CONST == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CONST == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -9716,8 +9703,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
                                value = EX_CONSTANT(opline->op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -9742,8 +9729,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
                        /* Consts, temporary variables and references need copying */
                        if (IS_CONST == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CONST == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -9770,8 +9757,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CV == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -11179,10 +11166,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T
                if (IS_CONST == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CONST == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CONST == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -12253,11 +12238,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPC
                        if (Z_TYPE_P(expr) == opline->extended_value) {
                                ZVAL_COPY_VALUE(result, expr);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
-                                               zval_copy_ctor_func(result);
-                                       }
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                                } else if (IS_TMP_VAR != IS_TMP_VAR) {
-                                       if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+                                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                                }
 
                                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -12270,9 +12253,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPC
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
                                                if (IS_TMP_VAR == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -12288,9 +12269,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPC
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_add_new(Z_OBJPROP_P(result), CG(known_strings)[ZEND_STR_SCALAR], expr);
                                                if (IS_TMP_VAR == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -12599,20 +12578,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_
                value = Z_REFVAL_P(value);
        }
        if (i_zend_is_true(value)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+
+               ZVAL_COPY_VALUE(result, value);
                if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_TMP_VAR == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_TMP_VAR == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -12640,20 +12619,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND
        }
 
        if (Z_TYPE_P(value) > IS_NULL) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+               ZVAL_COPY_VALUE(result, value);
                if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_TMP_VAR == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_TMP_VAR == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -12695,8 +12673,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEN
        } else {
                ZVAL_COPY_VALUE(result, value);
                if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(result);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
+                               Z_ADDREF_P(result);
                        }
                }
        }
@@ -13116,10 +13094,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_TMP_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -13258,8 +13234,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
                                value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -13284,8 +13260,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_TMP_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -13312,8 +13288,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_CONST == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CONST == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -13429,8 +13405,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
                                value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -13455,8 +13431,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_TMP_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -13483,8 +13459,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_TMP_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -13600,8 +13576,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
                                value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -13626,8 +13602,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_TMP_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -13654,8 +13630,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -13810,10 +13786,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_TMP_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -13952,8 +13926,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
                                value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -13978,8 +13952,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_TMP_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -14006,8 +13980,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
                /* Consts, temporary variables and references need copying */
                if (IS_UNUSED == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_UNUSED == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -14338,10 +14312,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_TMP_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -14480,8 +14452,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
                                value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -14506,8 +14478,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
                        /* Consts, temporary variables and references need copying */
                        if (IS_TMP_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_TMP_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -14534,8 +14506,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CV == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -14862,10 +14834,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_TMP_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_TMP_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -15762,11 +15732,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPC
                        if (Z_TYPE_P(expr) == opline->extended_value) {
                                ZVAL_COPY_VALUE(result, expr);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
-                                               zval_copy_ctor_func(result);
-                                       }
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                                } else if (IS_VAR != IS_TMP_VAR) {
-                                       if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+                                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                                }
 
                                zval_ptr_dtor_nogc(free_op1);
@@ -15780,9 +15748,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPC
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
                                                if (IS_VAR == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -15798,9 +15764,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPC
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_add_new(Z_OBJPROP_P(result), CG(known_strings)[ZEND_STR_SCALAR], expr);
                                                if (IS_VAR == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -16473,20 +16437,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_
                value = Z_REFVAL_P(value);
        }
        if (i_zend_is_true(value)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+
+               ZVAL_COPY_VALUE(result, value);
                if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_VAR == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_VAR == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -16514,20 +16478,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND
        }
 
        if (Z_TYPE_P(value) > IS_NULL) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+               ZVAL_COPY_VALUE(result, value);
                if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_VAR == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_VAR == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -16569,8 +16532,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEN
        } else {
                ZVAL_COPY_VALUE(result, value);
                if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(result);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
+                               Z_ADDREF_P(result);
                        }
                }
        }
@@ -19027,10 +18990,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -19303,8 +19264,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
                                value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -19330,8 +19291,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -19358,8 +19319,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_CONST == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CONST == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -19531,8 +19492,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
                                value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -19558,8 +19519,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -19586,8 +19547,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_TMP_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -19814,8 +19775,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
                                value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -19841,8 +19802,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -19869,8 +19830,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -20986,10 +20947,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -21143,8 +21102,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
                                value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -21170,8 +21129,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -21198,8 +21157,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
                /* Consts, temporary variables and references need copying */
                if (IS_UNUSED == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_UNUSED == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -23538,10 +23497,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -23814,8 +23771,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
                                value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -23841,8 +23798,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
                        /* Consts, temporary variables and references need copying */
                        if (IS_VAR == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_VAR == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -23869,8 +23826,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CV == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -26068,10 +26025,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP
                if (IS_VAR == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_VAR == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_VAR == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -28804,8 +28759,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
                                value = NULL;
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_UNUSED == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -28830,8 +28785,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
                        /* Consts, temporary variables and references need copying */
                        if (IS_UNUSED == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_UNUSED == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -28858,8 +28813,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
                /* Consts, temporary variables and references need copying */
                if (IS_CONST == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CONST == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -28939,8 +28894,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
                                value = NULL;
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_UNUSED == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -28965,8 +28920,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
                        /* Consts, temporary variables and references need copying */
                        if (IS_UNUSED == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_UNUSED == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -28993,8 +28948,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_TMP_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -29074,8 +29029,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
                                value = NULL;
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_UNUSED == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -29100,8 +29055,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
                        /* Consts, temporary variables and references need copying */
                        if (IS_UNUSED == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_UNUSED == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -29128,8 +29083,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -29796,8 +29751,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
                                value = NULL;
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_UNUSED == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -29822,8 +29777,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
                        /* Consts, temporary variables and references need copying */
                        if (IS_UNUSED == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_UNUSED == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -29850,8 +29805,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
                /* Consts, temporary variables and references need copying */
                if (IS_UNUSED == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_UNUSED == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -32094,8 +32049,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
                                value = NULL;
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_UNUSED == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -32120,8 +32075,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_UNUSED == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_UNUSED == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -32148,8 +32103,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CV == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -35408,11 +35363,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCO
                        if (Z_TYPE_P(expr) == opline->extended_value) {
                                ZVAL_COPY_VALUE(result, expr);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
-                                               zval_copy_ctor_func(result);
-                                       }
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                                } else if (IS_CV != IS_TMP_VAR) {
-                                       if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+                                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                                }
 
                                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -35425,9 +35378,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCO
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
                                                if (IS_CV == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -35443,9 +35394,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCO
                                        if (Z_TYPE_P(expr) != IS_NULL) {
                                                expr = zend_hash_add_new(Z_OBJPROP_P(result), CG(known_strings)[ZEND_STR_SCALAR], expr);
                                                if (IS_CV == IS_CONST) {
-                                                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
-                                                               zval_copy_ctor_func(expr);
-                                                       }
+                                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
                                                } else {
                                                        if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
                                                }
@@ -35832,20 +35781,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_O
                value = Z_REFVAL_P(value);
        }
        if (i_zend_is_true(value)) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+
+               ZVAL_COPY_VALUE(result, value);
                if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_CV == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_CV == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -35872,20 +35821,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_
        }
 
        if (Z_TYPE_P(value) > IS_NULL) {
-               ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+               zval *result = EX_VAR(opline->result.var);
+               ZVAL_COPY_VALUE(result, value);
                if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(EX_VAR(opline->result.var));
-                       }
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
                } else if (IS_CV == IS_CV) {
-                       if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+                       if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
                } else if (IS_CV == IS_VAR && ref) {
                        zend_reference *r = Z_REF_P(ref);
 
                        if (UNEXPECTED(--GC_REFCOUNT(r) == 0)) {
                                efree_size(r, sizeof(zend_reference));
-                       } else if (Z_OPT_REFCOUNTED_P(value)) {
-                               Z_ADDREF_P(value);
+                       } else if (Z_OPT_REFCOUNTED_P(result)) {
+                               Z_ADDREF_P(result);
                        }
                }
                ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
@@ -35926,8 +35874,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND
        } else {
                ZVAL_COPY_VALUE(result, value);
                if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
-                               zval_copy_ctor_func(result);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
+                               Z_ADDREF_P(result);
                        }
                }
        }
@@ -39301,10 +39249,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CV == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -39955,8 +39901,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
                                value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -39981,8 +39927,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CV == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -40009,8 +39955,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
                /* Consts, temporary variables and references need copying */
                if (IS_CONST == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CONST == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -40324,8 +40270,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
                                value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -40350,8 +40296,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CV == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -40378,8 +40324,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
                /* Consts, temporary variables and references need copying */
                if (IS_TMP_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_TMP_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -40936,8 +40882,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
                                value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -40962,8 +40908,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CV == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -40990,8 +40936,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
                /* Consts, temporary variables and references need copying */
                if (IS_VAR == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_VAR == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -42211,10 +42157,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CV == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -42657,8 +42601,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
                                value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -42683,8 +42627,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CV == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -42711,8 +42655,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
                /* Consts, temporary variables and references need copying */
                if (IS_UNUSED == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_UNUSED == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -45869,10 +45813,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CV == IS_CV) {
                        ZVAL_DEREF(expr_ptr);
@@ -46331,8 +46273,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
                                value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
                                ZVAL_COPY_VALUE(&generator->value, value);
                                if (IS_CV == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                               zval_copy_ctor_func(&generator->value);
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                               Z_ADDREF(generator->value);
                                        }
                                }
                        } else {
@@ -46357,8 +46299,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
                        /* Consts, temporary variables and references need copying */
                        if (IS_CV == IS_CONST) {
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               if (UNEXPECTED(Z_OPT_COPYABLE(generator->value))) {
-                                       zval_copy_ctor_func(&generator->value);
+                               if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
+                                       Z_ADDREF(generator->value);
                                }
                        } else if (IS_CV == IS_TMP_VAR) {
                                ZVAL_COPY_VALUE(&generator->value, value);
@@ -46385,8 +46327,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
                /* Consts, temporary variables and references need copying */
                if (IS_CV == IS_CONST) {
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       if (UNEXPECTED(Z_OPT_COPYABLE(generator->key))) {
-                               zval_copy_ctor_func(&generator->key);
+                       if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
+                               Z_ADDREF(generator->key);
                        }
                } else if (IS_CV == IS_TMP_VAR) {
                        ZVAL_COPY_VALUE(&generator->key, key);
@@ -49405,10 +49347,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV
                if (IS_CV == IS_TMP_VAR) {
                        /* pass */
                } else if (IS_CV == IS_CONST) {
-                       if (UNEXPECTED(Z_OPT_COPYABLE_P(expr_ptr))) {
-                               ZVAL_COPY_VALUE(&new_expr, expr_ptr);
-                               zval_copy_ctor_func(&new_expr);
-                               expr_ptr = &new_expr;
+                       if (Z_REFCOUNTED_P(expr_ptr)) {
+                               Z_ADDREF_P(expr_ptr);
                        }
                } else if (IS_CV == IS_CV) {
                        ZVAL_DEREF(expr_ptr);