Removed redundand code

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 578a319fd192af68fa262100d048518dff27a3d7..b7445c96620a3739c1709fb437a7608d3f01abdf 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2839,17 +2839,17 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
                if (OP1_TYPE == IS_TMP_VAR) {
                        FREE_OP1();
                }
-       } else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
+       } else {
                if (OP1_TYPE == IS_CONST ||
-                   (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
+                   OP1_TYPE == IS_TMP_VAR ||
+                   PZVAL_IS_REF(retval_ptr)) {
                        zval *ret;
 
                        ALLOC_ZVAL(ret);
                        INIT_PZVAL_COPY(ret, retval_ptr);
-                       zval_copy_ctor(ret);
+                       if (OP1_TYPE != IS_TMP_VAR) {
+                               zval_copy_ctor(ret);
+                       }
                        *EG(return_value_ptr_ptr) = ret;
                } else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
                           retval_ptr == &EG(uninitialized_zval)) {
@@ -2861,16 +2861,6 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
                        *EG(return_value_ptr_ptr) = retval_ptr;
                        Z_ADDREF_P(retval_ptr);
                }
-       } else {
-               zval *ret;
-
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
-               ALLOC_ZVAL(ret);
-               INIT_PZVAL_COPY(ret, retval_ptr);
-               *EG(return_value_ptr_ptr) = ret;
        }
        FREE_OP1_IF_VAR();
        ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
@@ -2886,10 +2876,6 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
 
        do {
-               if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
                if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 392569678dff80655b619cdc6bf2a01a9b95afec..ddbc39d68dbb8484cc553a114d35ba641ea2c6e4 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2333,17 +2333,17 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
                if (IS_CONST == IS_TMP_VAR) {
 
                }
-       } else if (!0) { /* Not a temp var */
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
+       } else {
                if (IS_CONST == IS_CONST ||
-                   (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
+                   IS_CONST == IS_TMP_VAR ||
+                   PZVAL_IS_REF(retval_ptr)) {
                        zval *ret;
 
                        ALLOC_ZVAL(ret);
                        INIT_PZVAL_COPY(ret, retval_ptr);
-                       zval_copy_ctor(ret);
+                       if (IS_CONST != IS_TMP_VAR) {
+                               zval_copy_ctor(ret);
+                       }
                        *EG(return_value_ptr_ptr) = ret;
                } else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
                           retval_ptr == &EG(uninitialized_zval)) {
@@ -2355,16 +2355,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
                        *EG(return_value_ptr_ptr) = retval_ptr;
                        Z_ADDREF_P(retval_ptr);
                }
-       } else {
-               zval *ret;
-
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
-               ALLOC_ZVAL(ret);
-               INIT_PZVAL_COPY(ret, retval_ptr);
-               *EG(return_value_ptr_ptr) = ret;
        }
 
        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -2380,10 +2370,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
        SAVE_OPLINE();
 
        do {
-               if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
                if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -7654,17 +7640,17 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (IS_TMP_VAR == IS_TMP_VAR) {
                        zval_dtor(free_op1.var);
                }
-       } else if (!1) { /* Not a temp var */
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
+       } else {
                if (IS_TMP_VAR == IS_CONST ||
-                   (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
+                   IS_TMP_VAR == IS_TMP_VAR ||
+                   PZVAL_IS_REF(retval_ptr)) {
                        zval *ret;
 
                        ALLOC_ZVAL(ret);
                        INIT_PZVAL_COPY(ret, retval_ptr);
-                       zval_copy_ctor(ret);
+                       if (IS_TMP_VAR != IS_TMP_VAR) {
+                               zval_copy_ctor(ret);
+                       }
                        *EG(return_value_ptr_ptr) = ret;
                } else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
                           retval_ptr == &EG(uninitialized_zval)) {
@@ -7676,16 +7662,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        *EG(return_value_ptr_ptr) = retval_ptr;
                        Z_ADDREF_P(retval_ptr);
                }
-       } else {
-               zval *ret;
-
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
-               ALLOC_ZVAL(ret);
-               INIT_PZVAL_COPY(ret, retval_ptr);
-               *EG(return_value_ptr_ptr) = ret;
        }
 
        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -7701,10 +7677,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
                if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -12888,17 +12860,17 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (IS_VAR == IS_TMP_VAR) {
                        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
                }
-       } else if (!0) { /* Not a temp var */
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
+       } else {
                if (IS_VAR == IS_CONST ||
-                   (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
+                   IS_VAR == IS_TMP_VAR ||
+                   PZVAL_IS_REF(retval_ptr)) {
                        zval *ret;
 
                        ALLOC_ZVAL(ret);
                        INIT_PZVAL_COPY(ret, retval_ptr);
-                       zval_copy_ctor(ret);
+                       if (IS_VAR != IS_TMP_VAR) {
+                               zval_copy_ctor(ret);
+                       }
                        *EG(return_value_ptr_ptr) = ret;
                } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
                           retval_ptr == &EG(uninitialized_zval)) {
@@ -12910,16 +12882,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        *EG(return_value_ptr_ptr) = retval_ptr;
                        Z_ADDREF_P(retval_ptr);
                }
-       } else {
-               zval *ret;
-
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
-               ALLOC_ZVAL(ret);
-               INIT_PZVAL_COPY(ret, retval_ptr);
-               *EG(return_value_ptr_ptr) = ret;
        }
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -12935,10 +12897,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
                if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -30534,17 +30492,17 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (IS_CV == IS_TMP_VAR) {
 
                }
-       } else if (!0) { /* Not a temp var */
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
+       } else {
                if (IS_CV == IS_CONST ||
-                   (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
+                   IS_CV == IS_TMP_VAR ||
+                   PZVAL_IS_REF(retval_ptr)) {
                        zval *ret;
 
                        ALLOC_ZVAL(ret);
                        INIT_PZVAL_COPY(ret, retval_ptr);
-                       zval_copy_ctor(ret);
+                       if (IS_CV != IS_TMP_VAR) {
+                               zval_copy_ctor(ret);
+                       }
                        *EG(return_value_ptr_ptr) = ret;
                } else if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
                           retval_ptr == &EG(uninitialized_zval)) {
@@ -30556,16 +30514,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                        *EG(return_value_ptr_ptr) = retval_ptr;
                        Z_ADDREF_P(retval_ptr);
                }
-       } else {
-               zval *ret;
-
-               if (*EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
-               ALLOC_ZVAL(ret);
-               INIT_PZVAL_COPY(ret, retval_ptr);
-               *EG(return_value_ptr_ptr) = ret;
        }
 
        return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -30581,10 +30529,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
        SAVE_OPLINE();
 
        do {
-               if (EG(return_value_ptr_ptr) && *EG(return_value_ptr_ptr)) {
-                       zval_ptr_dtor(EG(return_value_ptr_ptr));
-               }
-
                if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");