ZEND_FETCH_*_R operations simplified and can't be used with EXT_TYPE_UNUSED flag...

diff --git a/NEWS b/NEWS
index 8f30d25412959418c70844c0d65b57c9ff15431c..dc404d68026e83e4ae2935d96341009cc4d047c1 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -22,6 +22,9 @@ PHP                                                                        NEWS
   . $GLOBALS became a JIT autoglobal, so it's initialized only if used
     (this may affect opcode caches)
   . simplified string ofset reading. $str[1][0] now is a legal construct.
+  . ZEND_FETCH_*_R operations simplified and can't be used with EXT_TYPE_UNUSED
+    flag any more. Thit is very rare and useless case. ZEND_FREE might be
+    required after them instead.
 - Added concept of interned strings. All strings constants known at compile
   time are allocated in a single copy and never changed. (Dmitry)
 - Added an optimization which saves memory and emalloc/efree calls for empty

diff --git a/Zend/tests/bug39018.phpt b/Zend/tests/bug39018.phpt
index 6de9092c9f369c6693a569c7b12c5341957a2d76..1c67eb298970357ede5a8ee9bdc20b6e2d410f0d 100644 (file)
--- a/Zend/tests/bug39018.phpt
+++ b/Zend/tests/bug39018.phpt
@@ -63,10 +63,18 @@ print "\nDone\n";
 ?>
 --EXPECTF--
 
+Notice: Uninitialized string offset: %i in %s on line 6
+
+Notice: Uninitialized string offset: 0 in %s on line 10
+
 Notice: Uninitialized string offset: 0 in %s on line 12
 
+Notice: Uninitialized string offset: %i in %s on line 14
+
 Notice: Uninitialized string offset: %i in %s on line 16
 
+Notice: Uninitialized string offset: 0 in %s on line 18
+
 Notice: Uninitialized string offset: 4 in %s on line 28
 
 Notice: Uninitialized string offset: 4 in %s on line 34
@@ -77,6 +85,8 @@ Notice: Uninitialized string offset: 4 in %s on line 42
 
 Notice: Uninitialized string offset: 4 in %s on line 46
 
+Notice: Uninitialized string offset: 12 in %s on line 50
+
 Notice: Uninitialized string offset: 12 in %s on line 52
 b
 Done

diff --git a/Zend/tests/result_unused.phpt b/Zend/tests/result_unused.phpt
new file mode 100644 (file)
index 0000000..ed8502c
--- /dev/null
+++ b/Zend/tests/result_unused.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Unused result of fetch operations
+--FILE--
+<?php
+$x = array(1);
+$a = "x";
+$$a;
+
+$x = array(array(2));
+$x[0];
+
+$x = "str";
+$x[0];
+$x[3];
+
+class Foo {
+       public $prop = array(3);
+       function __get($name) {
+               return array(4);
+       }
+}
+$x = new Foo();
+$x->prop;
+$x->y;
+echo "ok\n";
+--EXPECTF--
+Notice: Uninitialized string offset: 3 in %sresult_unused.php on line 11
+ok
+

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index a783d4ff5ff45d96ed594f6f626a3c77bf3b4806..ce19bd3cd88d91cdb905cda6f124ac1395cd9f64 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1422,7 +1422,19 @@ void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
                }
                if (opline->result_type == IS_VAR
                        && opline->result.var == op1->u.op.var) {
-                       opline->result_type |= EXT_TYPE_UNUSED;
+                       if (opline->opcode == ZEND_FETCH_R ||
+                           opline->opcode == ZEND_FETCH_DIM_R ||
+                           opline->opcode == ZEND_FETCH_OBJ_R) {
+                               /* It's very rare and useless case. It's better to use
+                                  additional FREE opcode and simplify the FETCH handlers
+                                  their selves */
+                               opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+                               opline->opcode = ZEND_FREE;
+                               SET_NODE(opline->op1, op1);
+                               SET_UNUSED(opline->op2);
+                       } else {
+                               opline->result_type |= EXT_TYPE_UNUSED;
+                       }
                } else {
                        while (opline>CG(active_op_array)->opcodes) {
                                if (opline->opcode == ZEND_FETCH_DIM_R
@@ -6065,7 +6077,7 @@ int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, ze
 {
        zend_auto_global auto_global;
 
-       auto_global.name = zend_new_interned_string(name, name_len + 1, 0 TSRMLS_CC);
+       auto_global.name = zend_new_interned_string((char*)name, name_len + 1, 0 TSRMLS_CC);
        auto_global.name_len = name_len;
        auto_global.auto_global_callback = auto_global_callback;
        auto_global.jit = jit;

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index d6d6a33ded5e34eb356918725fdef82c8e14c9e6..b71196ecb12f2f10c5e2f0de4619ed2bbc9904c2 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1218,23 +1218,18 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval **cont
 
                case IS_ARRAY:
                        retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
-                       if (result) {
-                               AI_SET_PTR(result, *retval);
-                               PZVAL_LOCK(*retval);
-                       }
+                       AI_SET_PTR(result, *retval);
+                       PZVAL_LOCK(*retval);
                        return;
-                       break;
 
                case IS_NULL:
-                       if (result) {
-                               AI_SET_PTR(result, &EG(uninitialized_zval));
-                               PZVAL_LOCK(&EG(uninitialized_zval));
-                       }
+                       AI_SET_PTR(result, &EG(uninitialized_zval));
+                       PZVAL_LOCK(&EG(uninitialized_zval));
                        return;
-                       break;
 
                case IS_STRING: {
                                zval tmp;
+                               zval *ptr;
 
                                if (Z_TYPE_P(dim) != IS_LONG) {
                                        switch(Z_TYPE_P(dim)) {
@@ -1255,25 +1250,22 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval **cont
                                        convert_to_long(&tmp);
                                        dim = &tmp;
                                }
-                               if (result) {
-                                       zval *ptr;
-
-                                       ALLOC_ZVAL(ptr);
-                                       INIT_PZVAL(ptr);
-                                       Z_TYPE_P(ptr) = IS_STRING;
-
-                                       if (Z_LVAL_P(dim) < 0 || Z_STRLEN_P(container) <= Z_LVAL_P(dim)) {
-                                               zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
-                                               Z_STRVAL_P(ptr) = STR_EMPTY_ALLOC();
-                                               Z_STRLEN_P(ptr) = 0;
-                                       } else {
-                                               Z_STRVAL_P(ptr) = (char*)emalloc(2);
-                                               Z_STRVAL_P(ptr)[0] = Z_STRVAL_P(container)[Z_LVAL_P(dim)];
-                                               Z_STRVAL_P(ptr)[1] = 0;
-                                               Z_STRLEN_P(ptr) = 1;                                            
-                                       }
-                                       AI_SET_PTR(result, ptr);
+
+                               ALLOC_ZVAL(ptr);
+                               INIT_PZVAL(ptr);
+                               Z_TYPE_P(ptr) = IS_STRING;
+
+                               if (Z_LVAL_P(dim) < 0 || Z_STRLEN_P(container) <= Z_LVAL_P(dim)) {
+                                       zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
+                                       Z_STRVAL_P(ptr) = STR_EMPTY_ALLOC();
+                                       Z_STRLEN_P(ptr) = 0;
+                               } else {
+                                       Z_STRVAL_P(ptr) = (char*)emalloc(2);
+                                       Z_STRVAL_P(ptr)[0] = Z_STRVAL_P(container)[Z_LVAL_P(dim)];
+                                       Z_STRVAL_P(ptr)[1] = 0;
+                                       Z_STRLEN_P(ptr) = 1;                                            
                                }
+                               AI_SET_PTR(result, ptr);
                                return;
                        }
                        break;
@@ -1292,14 +1284,8 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval **cont
                                overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
 
                                if (overloaded_result) {
-                                       if (result) {
-                                               AI_SET_PTR(result, overloaded_result);
-                                               PZVAL_LOCK(overloaded_result);
-                                       } else if (Z_REFCOUNT_P(overloaded_result) == 0) {
-                                               /* Destroy unused result from offsetGet() magic method */
-                                               Z_SET_REFCOUNT_P(overloaded_result, 1);
-                                               zval_ptr_dtor(&overloaded_result);
-                                       }
+                                       AI_SET_PTR(result, overloaded_result);
+                                       PZVAL_LOCK(overloaded_result);
                                } else if (result) {
                                        AI_SET_PTR(result, &EG(uninitialized_zval));
                                        PZVAL_LOCK(&EG(uninitialized_zval));
@@ -1309,15 +1295,11 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval **cont
                                }
                        }
                        return;
-                       break;
 
                default:
-                       if (result) {
-                               AI_SET_PTR(result, &EG(uninitialized_zval));
-                               PZVAL_LOCK(&EG(uninitialized_zval));
-                       }
+                       AI_SET_PTR(result, &EG(uninitialized_zval));
+                       PZVAL_LOCK(&EG(uninitialized_zval));
                        return;
-                       break;
        }
 }
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index d5ac20fc0c986a83ec57a7dbda03112dbc0395a5..afa1532bfa2c23981465c41769dfedd8dc934f1e 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1105,31 +1105,29 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
        if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -1182,7 +1180,7 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, VAR|CV, CONST|TMP|VAR|CV)
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
        FREE_OP2();
        FREE_OP1_VAR_PTR();
        CHECK_EXCEPTION();
@@ -1345,10 +1343,8 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                FREE_OP2();
        } else {
                zval *retval;
@@ -1360,16 +1356,8 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (IS_OP2_TMP_FREE()) {
                        zval_ptr_dtor(&offset);
@@ -1480,10 +1468,8 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                FREE_OP2();
        } else {
                zval *retval;
@@ -1495,16 +1481,8 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (IS_OP2_TMP_FREE()) {
                        zval_ptr_dtor(&offset);
@@ -1608,10 +1586,8 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, CONST|TMP, CONST)
        container = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
        } else {
                zend_free_op free_op2;
                zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
@@ -2008,12 +1984,16 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(70, ZEND_FREE, TMP, ANY)
+ZEND_VM_HANDLER(70, ZEND_FREE, TMP|VAR, ANY)
 {
        USE_OPLINE
 
        SAVE_OPLINE();
-       zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+       if (OP1_TYPE == IS_TMP_VAR) {
+               zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+       } else {
+               zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 620f24538042d70a48b2725e2c70e187361afbd1..43ac7dbd1a364800af553963f03dc15b012ac475 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2756,31 +2756,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
        if (IS_CONST != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -2828,10 +2826,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
        container = opline->op1.zv;
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
        } else {
 
                zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
@@ -4229,31 +4225,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
        if (IS_CONST != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -4757,31 +4751,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
        if (IS_CONST != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -5978,7 +5970,11 @@ static int ZEND_FASTCALL  ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        USE_OPLINE
 
        SAVE_OPLINE();
-       zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+       if (IS_TMP_VAR == IS_TMP_VAR) {
+               zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+       } else {
+               zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -7062,31 +7058,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
        if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -7134,10 +7128,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
        container = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
        } else {
 
                zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
@@ -8408,31 +8400,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
        if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -8938,31 +8928,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
        if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -10148,6 +10136,20 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_TMP_VAR) {
+               zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+       } else {
+               zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11925,31 +11927,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
        if (IS_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -12001,7 +12001,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
@@ -12164,10 +12164,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -12179,16 +12177,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -12299,10 +12289,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -12314,16 +12302,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -14151,7 +14131,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
@@ -14314,10 +14294,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -14329,16 +14307,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -14449,10 +14419,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -14464,16 +14432,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -16150,31 +16110,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
        if (IS_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -16226,7 +16184,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
@@ -16389,10 +16347,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -16404,16 +16360,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -16524,10 +16472,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -16539,16 +16485,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -17936,31 +17874,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
        if (IS_VAR != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -19272,7 +19208,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
@@ -19435,10 +19371,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -19450,16 +19384,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -19570,10 +19496,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -19585,16 +19509,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -21045,10 +20961,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -21060,16 +20974,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -21178,10 +21084,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -21193,16 +21097,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -22301,10 +22197,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -22316,16 +22210,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -22434,10 +22320,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -22449,16 +22333,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -23466,10 +23342,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -23481,16 +23355,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -23599,10 +23465,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -23614,16 +23478,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -24899,10 +24755,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -24914,16 +24768,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -25032,10 +24878,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -25047,16 +24891,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -27595,31 +27431,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
        if (IS_CV != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -27671,7 +27505,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -27833,10 +27667,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -27848,16 +27680,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -27966,10 +27790,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -27981,16 +27803,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -29604,7 +29418,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
        zval_dtor(free_op2.var);
 
        CHECK_EXCEPTION();
@@ -29766,10 +29580,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -29781,16 +29593,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -29899,10 +29703,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -29914,16 +29716,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -31477,31 +31271,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
        if (IS_CV != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -31553,7 +31345,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
        CHECK_EXCEPTION();
@@ -31715,10 +31507,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -31730,16 +31520,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -31848,10 +31630,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
                if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        } else {
                zval *retval;
@@ -31863,16 +31643,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -33136,31 +32908,29 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
        if (IS_CV != IS_CONST && varname == &tmp_varname) {
                zval_dtor(&tmp_varname);
        }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
+       if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+               SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+       }
+       PZVAL_LOCK(*retval);
+       switch (type) {
+               case BP_VAR_R:
+               case BP_VAR_IS:
+                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       break;
+               case BP_VAR_UNSET: {
+                       zend_free_op free_res;
 
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
+                       PZVAL_UNLOCK(*retval, &free_res);
+                       if (retval != &EG(uninitialized_zval_ptr)) {
+                               SEPARATE_ZVAL_IF_NOT_REF(retval);
                        }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
+                       PZVAL_LOCK(*retval);
+                       FREE_OP_VAR_PTR(free_res);
                }
+               /* break missing intentionally */
+               default:
+                       EX_T(opline->result.var).var.ptr_ptr = retval;
+                       break;
        }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -34357,7 +34127,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
                PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
        }
        container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read(!RETURN_VALUE_USED(opline)?NULL:&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+       zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -34519,10 +34289,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -34534,16 +34302,8 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -34652,10 +34412,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-               if (RETURN_VALUE_USED(opline)) {
-                       PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
-               }
+               PZVAL_LOCK(&EG(uninitialized_zval));
+               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
 
        } else {
                zval *retval;
@@ -34667,16 +34425,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
                /* here we are sure we are dealing with an object */
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
-               if (!RETURN_VALUE_USED(opline)) {
-                       if (Z_REFCOUNT_P(retval) == 0) {
-                               GC_REMOVE_ZVAL_FROM_BUFFER(retval);
-                               zval_dtor(retval);
-                               FREE_ZVAL(retval);
-                       }
-               } else {
-                       PZVAL_LOCK(retval);
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
-               }
+               PZVAL_LOCK(retval);
+               AI_SET_PTR(&EX_T(opline->result.var), retval);
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -37212,11 +36962,11 @@ void zend_init_opcodes_handlers(void)
        ZEND_FREE_SPEC_TMP_HANDLER,
        ZEND_FREE_SPEC_TMP_HANDLER,
        ZEND_FREE_SPEC_TMP_HANDLER,
-       ZEND_NULL_HANDLER,
-       ZEND_NULL_HANDLER,
-       ZEND_NULL_HANDLER,
-       ZEND_NULL_HANDLER,
-       ZEND_NULL_HANDLER,
+       ZEND_FREE_SPEC_VAR_HANDLER,
+       ZEND_FREE_SPEC_VAR_HANDLER,
+       ZEND_FREE_SPEC_VAR_HANDLER,
+       ZEND_FREE_SPEC_VAR_HANDLER,
+       ZEND_FREE_SPEC_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,