Replace deprecated conditions by ZEND_ASSERT.

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 0f71978072fd51cc340ba407f61ce1b68a1500ba..9aedf8bebb010d4e72a0dbc00f685000f73b004d 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4355,8 +4355,8 @@ ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC)
                retval_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
                if (OP1_TYPE == IS_VAR) {
-                       if (retval_ptr == &EG(uninitialized_zval) ||
-                           (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) {
+                       ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+                       if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
                                zend_error(E_NOTICE, "Only variable references should be returned by reference");
                                if (EX(return_value)) {
                                        ZVAL_NEW_REF(EX(return_value), retval_ptr);
@@ -7621,20 +7621,23 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (OP1_TYPE == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (OP1_TYPE == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                FREE_OP1_VAR_PTR();
                        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index ebf2cca3b81513e04649403b127cdf32beeb7388..d7084d6f10928cc06a140854fe0cffadee6e65a7 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -3570,8 +3570,8 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPE
                retval_ptr = NULL;
 
                if (IS_CONST == IS_VAR) {
-                       if (retval_ptr == &EG(uninitialized_zval) ||
-                           (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) {
+                       ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+                       if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
                                zend_error(E_NOTICE, "Only variable references should be returned by reference");
                                if (EX(return_value)) {
                                        ZVAL_NEW_REF(EX(return_value), retval_ptr);
@@ -6422,20 +6422,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CONST == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CONST == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -8345,20 +8348,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CONST == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CONST == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -8482,20 +8488,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CONST == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CONST == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -9249,20 +9258,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CONST == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CONST == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -10737,20 +10749,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CONST == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CONST == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -16569,8 +16584,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER
                retval_ptr = NULL;
 
                if (IS_TMP_VAR == IS_VAR) {
-                       if (retval_ptr == &EG(uninitialized_zval) ||
-                           (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) {
+                       ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+                       if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
                                zend_error(E_NOTICE, "Only variable references should be returned by reference");
                                if (EX(return_value)) {
                                        ZVAL_NEW_REF(EX(return_value), retval_ptr);
@@ -17511,20 +17526,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_TMP_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_TMP_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -17960,20 +17978,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEN
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_TMP_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_TMP_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -18097,20 +18118,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_TMP_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_TMP_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -18414,20 +18438,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_TMP_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_TMP_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -18883,20 +18910,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_TMP_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_TMP_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -19401,8 +19431,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER
                retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
                if (IS_VAR == IS_VAR) {
-                       if (retval_ptr == &EG(uninitialized_zval) ||
-                           (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) {
+                       ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+                       if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
                                zend_error(E_NOTICE, "Only variable references should be returned by reference");
                                if (EX(return_value)) {
                                        ZVAL_NEW_REF(EX(return_value), retval_ptr);
@@ -22837,20 +22867,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
@@ -25101,20 +25134,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEN
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
@@ -25371,20 +25407,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
@@ -26514,20 +26553,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
@@ -28863,20 +28905,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_VAR == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_VAR == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                        }
@@ -30942,20 +30987,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_UNUSED == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_UNUSED == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -32679,20 +32727,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_UNUSED == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_UNUSED == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -32816,20 +32867,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_UNUSED == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_UNUSED == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -33278,20 +33332,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_UNUSED == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_UNUSED == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -35169,20 +35226,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_UNUSED == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_UNUSED == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -35888,8 +35948,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(
                retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
 
                if (IS_CV == IS_VAR) {
-                       if (retval_ptr == &EG(uninitialized_zval) ||
-                           (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr))) {
+                       ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+                       if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
                                zend_error(E_NOTICE, "Only variable references should be returned by reference");
                                if (EX(return_value)) {
                                        ZVAL_NEW_REF(EX(return_value), retval_ptr);
@@ -40153,20 +40213,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CV == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CV == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -43391,20 +43454,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CV == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CV == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -43709,20 +43775,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CV == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CV == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -44971,20 +45040,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CV == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CV == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {
@@ -48208,20 +48280,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
 
                                /* If a function call result is yielded and the function did
                                 * not return by reference we throw a notice. */
-                               if (IS_CV == IS_VAR &&
-                                   (value_ptr == &EG(uninitialized_zval) ||
-                                    (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-                                     !Z_ISREF_P(value_ptr)))) {
-                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-                                       ZVAL_COPY(&generator->value, value_ptr);
-                               } else {
+                               do {
+                                       if (IS_CV == IS_VAR) {
+                                               ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
+                                               if (opline->extended_value == ZEND_RETURNS_FUNCTION
+                                                && !Z_ISREF_P(value_ptr)) {
+                                                       zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+                                                       ZVAL_COPY(&generator->value, value_ptr);
+                                                       break;
+                                               }
+                                       }
                                        if (Z_ISREF_P(value_ptr)) {
                                                Z_ADDREF_P(value_ptr);
                                        } else {
                                                ZVAL_MAKE_REF_EX(value_ptr, 2);
                                        }
                                        ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
-                               }
+                               } while (0);
 
                        }
                } else {