Generator related fixes

diff --git a/Zend/zend.c b/Zend/zend.c
index 19401d2e0365f61fb750000c7d3acbc90ed42e51..e8a6a40ff6a4f2c52974906e2c03d2da707620f9 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -319,6 +319,7 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
 {
        zval expr_copy;
        int use_copy;
+       int ret;
 
        zend_make_printable_zval(expr, &expr_copy, &use_copy);
        if (use_copy) {
@@ -331,10 +332,11 @@ ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int in
                return 0;
        }
        write_func(Z_STRVAL_P(expr), Z_STRLEN_P(expr));
+       ret = Z_STRLEN_P(expr);
        if (use_copy) {
                zval_dtor(expr);
        }
-       return Z_STRLEN_P(expr);
+       return ret;
 }
 /* }}} */
 
@@ -366,7 +368,7 @@ ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */
                                zend_printf("%s Object (", "Unknown Class");
                        }
                        if (class_name) {
-                               efree((char*)class_name);
+                               STR_RELEASE(class_name);
                        }
                        if (Z_OBJ_HANDLER_P(expr, get_properties)) {
                                properties = Z_OBJPROP_P(expr);

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 9bdee5c2c1ae6003cab20008156fecbd51602492..e2bffd8dbf0dc7583042cd26c0750272255b7f6e 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -699,6 +699,9 @@ static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zva
                        need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
                        return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, "none", "" TSRMLS_CC);
                }
+               if (Z_TYPE_P(arg) == IS_REFERENCE) {
+                       arg = Z_REFVAL_P(arg);
+               }
                if (Z_TYPE_P(arg) == IS_OBJECT) {
                        need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
                        if (!ce || !instanceof_function(Z_OBJCE_P(arg), ce TSRMLS_CC)) {
@@ -715,6 +718,9 @@ static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zva
                                        return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", "none", "" TSRMLS_CC);
                                }
 
+                               if (Z_TYPE_P(arg) == IS_REFERENCE) {
+                                       arg = Z_REFVAL_P(arg);
+                               }
                                if (Z_TYPE_P(arg) != IS_ARRAY && (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null)) {
                                        return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", zend_zval_type_name(arg), "" TSRMLS_CC);
                                }
@@ -1612,19 +1618,19 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
                 * and the passed arguments
                 */
                int args_count = zend_vm_stack_get_args_count_ex(EG(current_execute_data));
-               size_t args_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * (args_count + 1);
+               size_t args_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * (args_count + 1);
 
                total_size += args_size + execute_data_size;
 
-               EG(argument_stack) = zend_vm_stack_new_page((total_size + (sizeof(void*) - 1)) / sizeof(void*));
+               EG(argument_stack) = zend_vm_stack_new_page((total_size + (sizeof(zval) - 1)) / sizeof(zval));
                EG(argument_stack)->prev = NULL;
-               execute_data = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + args_size + execute_data_size + vars_size);
+               execute_data = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + execute_data_size + args_size);
 
                /* copy prev_execute_data */
-               EX(prev_execute_data) = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + args_size);
+               EX(prev_execute_data) = (zend_execute_data*)ZEND_VM_STACK_ELEMETS(EG(argument_stack));
                memset(EX(prev_execute_data), 0, sizeof(zend_execute_data));
                EX(prev_execute_data)->function_state.function = (zend_function*)op_array;
-               EX(prev_execute_data)->function_state.arguments = (zval*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * args_count);
+               EX(prev_execute_data)->function_state.arguments = (zval*)(((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + execute_data_size + args_size - sizeof(zval)));
 
                /* copy arguments */
                ZVAL_LONG(EX(prev_execute_data)->function_state.arguments, args_count);

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index d6b4a3b0adedabb06bc1f5bd64c046924992c456..f1affbc01eb4b70a717f3571de063e5dc80b0f32 100644 (file)
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -35,7 +35,7 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
        zend_op_array *op_array = execute_data->op_array;
 
        if (generator->send_target) {
-               Z_DELREF_P(generator->send_target);
+               if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
                generator->send_target = NULL;
        }
 
@@ -302,6 +302,9 @@ ZEND_API void zend_generator_create_zval(zend_op_array *op_array, zval *return_v
        generator->execute_data = execute_data;
        generator->stack = EG(argument_stack);
        EG(argument_stack) = current_stack;
+
+       /* EX(return_value) keeps pointer to zend_object (not a real zval) */
+       execute_data->return_value = (zval*)generator;
 }
 /* }}} */
 
@@ -515,9 +518,8 @@ ZEND_METHOD(Generator, send)
 
        /* Put sent value in the target VAR slot, if it is used */
        if (generator->send_target) {
-               Z_DELREF_P(generator->send_target);
-               Z_ADDREF_P(value);
-               ZVAL_COPY_VALUE(generator->send_target, value);
+               if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
+               ZVAL_COPY(generator->send_target, value);
        }
 
        zend_generator_resume(generator TSRMLS_CC);
@@ -672,6 +674,21 @@ zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *ob
        }
 
        iterator = &generator->iterator;
+       
+//???
+#if 1
+       iterator->intern.std.gc.refcount = 1;
+       iterator->intern.std.gc.u.v.type = IS_OBJECT;
+       iterator->intern.std.gc.u.v.flags = 0;
+       iterator->intern.std.gc.u.v.buffer = 0;
+       iterator->intern.std.ce = NULL;
+       iterator->intern.std.properties = NULL;
+       iterator->intern.std.guards = NULL;
+       zend_objects_store_put(&iterator->intern.std);
+#else
+       zend_object_std_init(&iterator->intern.std, ???);
+#endif
+
        iterator->intern.funcs = &zend_generator_iterator_functions;
        iterator->intern.data = (void *) generator;
 

diff --git a/Zend/zend_iterators.c b/Zend/zend_iterators.c
index bb41ab9000ac003d1b3c74ec94ba315fdab69784..7610aadfc8f4cf75e73a3cb8ff2db363104ac080 100644 (file)
--- a/Zend/zend_iterators.c
+++ b/Zend/zend_iterators.c
@@ -67,7 +67,9 @@ static void iter_wrapper_dtor(zend_object *object TSRMLS_DC)
 
 ZEND_API void zend_iterator_wrap(zend_object_iterator *iter, zval *wrapped TSRMLS_DC)
 {
-       ZVAL_OBJ(wrapped, &iter->std); 
+       ZVAL_OBJ(wrapped, &iter->std);
+       //??? hack (it would be better implement it in anothe way)
+       Z_OBJ_HT_P(wrapped) = &iterator_object_handlers;
 }
 
 ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index b91e4894cf77b592ac702bc2d22723c7537dd90c..a469bc539b250eca85d5ced7d76afeee37d3dc49 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2881,8 +2881,8 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 
 ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, ANY, ANY)
 {
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        /* Close the generator to free up resources */
        zend_generator_close(generator, 1 TSRMLS_CC);
@@ -5306,8 +5306,8 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -5370,7 +5370,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!IS_OP1_TMP_FREE()) {
@@ -5380,7 +5380,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                                FREE_OP1_IF_VAR();
                        } else {
                                if (OP1_TYPE == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -5401,7 +5401,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!IS_OP2_TMP_FREE()) {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index f2ebf3f7ee33043138bf14481db6733b8644cd6c..3b322b86c50965292ae2b61a28867ab1612bff0d 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -681,8 +681,8 @@ static int ZEND_FASTCALL  ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 
 static int ZEND_FASTCALL  ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        /* Close the generator to free up resources */
        zend_generator_close(generator, 1 TSRMLS_CC);
@@ -4219,8 +4219,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -4282,7 +4282,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -4291,7 +4291,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 
                        } else {
                                if (IS_CONST == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -4312,7 +4312,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -4866,8 +4866,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -4929,7 +4929,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -4938,7 +4938,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 
                        } else {
                                if (IS_CONST == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -4959,7 +4959,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!1) {
@@ -5841,8 +5841,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -5904,7 +5904,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -5913,7 +5913,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 
                        } else {
                                if (IS_CONST == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -5934,7 +5934,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -6527,8 +6527,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -6590,7 +6590,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -6599,7 +6599,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 
                        } else {
                                if (IS_CONST == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -6620,7 +6620,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -7232,8 +7232,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -7295,7 +7295,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -7304,7 +7304,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
                        } else {
                                if (IS_CONST == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -7325,7 +7325,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -9193,8 +9193,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -9256,7 +9256,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!1) {
@@ -9265,7 +9265,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
                        } else {
                                if (IS_TMP_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -9286,7 +9286,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -9848,8 +9848,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -9911,7 +9911,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!1) {
@@ -9920,7 +9920,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 
                        } else {
                                if (IS_TMP_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -9941,7 +9941,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!1) {
@@ -10831,8 +10831,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -10894,7 +10894,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!1) {
@@ -10903,7 +10903,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 
                        } else {
                                if (IS_TMP_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -10924,7 +10924,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -11388,8 +11388,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -11451,7 +11451,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!1) {
@@ -11460,7 +11460,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 
                        } else {
                                if (IS_TMP_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -11481,7 +11481,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -12040,8 +12040,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -12103,7 +12103,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!1) {
@@ -12112,7 +12112,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
                        } else {
                                if (IS_TMP_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -12133,7 +12133,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -15811,8 +15811,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -15875,7 +15875,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -15885,7 +15885,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                                zval_ptr_dtor_nogc(free_op1.var);
                        } else {
                                if (IS_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -15906,7 +15906,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -17804,8 +17804,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -17868,7 +17868,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -17878,7 +17878,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                                zval_ptr_dtor_nogc(free_op1.var);
                        } else {
                                if (IS_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -17899,7 +17899,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!1) {
@@ -20184,8 +20184,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -20248,7 +20248,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -20258,7 +20258,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                                zval_ptr_dtor_nogc(free_op1.var);
                        } else {
                                if (IS_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -20279,7 +20279,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -21287,8 +21287,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -21351,7 +21351,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -21361,7 +21361,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                                zval_ptr_dtor_nogc(free_op1.var);
                        } else {
                                if (IS_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -21382,7 +21382,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -23334,8 +23334,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -23398,7 +23398,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -23408,7 +23408,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                                zval_ptr_dtor_nogc(free_op1.var);
                        } else {
                                if (IS_VAR == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -23429,7 +23429,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -24766,8 +24766,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -24829,7 +24829,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -24838,7 +24838,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 
                        } else {
                                if (IS_UNUSED == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -24859,7 +24859,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -26032,8 +26032,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -26095,7 +26095,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -26104,7 +26104,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
 
                        } else {
                                if (IS_UNUSED == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -26125,7 +26125,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!1) {
@@ -27298,8 +27298,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -27361,7 +27361,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -27370,7 +27370,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
 
                        } else {
                                if (IS_UNUSED == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -27391,7 +27391,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -27700,8 +27700,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -27763,7 +27763,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -27772,7 +27772,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 
                        } else {
                                if (IS_UNUSED == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -27793,7 +27793,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -28963,8 +28963,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -29026,7 +29026,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -29035,7 +29035,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
                        } else {
                                if (IS_UNUSED == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -29056,7 +29056,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -32354,8 +32354,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -32417,7 +32417,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -32426,7 +32426,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
                        } else {
                                if (IS_CV == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -32447,7 +32447,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -34221,8 +34221,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -34284,7 +34284,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -34293,7 +34293,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
                        } else {
                                if (IS_CV == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -34314,7 +34314,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!1) {
@@ -36475,8 +36475,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -36538,7 +36538,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -36547,7 +36547,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
                        } else {
                                if (IS_CV == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -36568,7 +36568,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -37446,8 +37446,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -37509,7 +37509,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -37518,7 +37518,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 
                        } else {
                                if (IS_CV == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -37539,7 +37539,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {
@@ -39367,8 +39367,8 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
        USE_OPLINE
 
-       /* The generator object is stored in return_value_ptr_ptr */
-       zend_generator *generator = (zend_generator *) Z_OBJ_P(EX(return_value));
+       /* The generator object is stored in EX(return_value) */
+       zend_generator *generator = (zend_generator *) EX(return_value);
 
        if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
                zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
@@ -39430,7 +39430,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                        ) {
 //???                          INIT_PZVAL_COPY(copy, value);
                                ZVAL_COPY_VALUE(&generator->value, value);
-                               Z_SET_REFCOUNT(generator->value, 1);
+                               if (Z_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
                                /* Temporary variables don't need ctor copying */
                                if (!0) {
@@ -39439,7 +39439,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
                        } else {
                                if (IS_CV == IS_CV) {
-                                       Z_ADDREF_P(value);
+                                       if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
                                }
                                ZVAL_COPY_VALUE(&generator->value, value);
                        }
@@ -39460,7 +39460,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                ) {
 //???                  INIT_PZVAL_COPY(copy, key);
                        ZVAL_COPY_VALUE(&generator->key, key);
-                       Z_SET_REFCOUNT(generator->key, 1);
+                       if (Z_REFCOUNTED(generator->key)) Z_SET_REFCOUNT(generator->key, 1);
 
                        /* Temporary variables don't need ctor copying */
                        if (!0) {