Removed deprecated AI_SET_PTR()s

diff --git a/Zend/tests/closure_018.phpt b/Zend/tests/closure_018.phpt
index d98c78aeacec8a00c3acf9ed8ca2e70c4bc87a6e..3b2d6beaa5382ec3423ca673b5b19684df357e9a 100644 (file)
--- a/Zend/tests/closure_018.phpt
+++ b/Zend/tests/closure_018.phpt
@@ -22,7 +22,10 @@ var_dump($y, $x);
 
 ?>
 --EXPECT--
+Notice: Only variable references should be returned by reference in %sclosure_018.php on line 7
 int(4)
+
+Notice: Only variable references should be returned by reference in %sclosure_018.php on line 7
 int(16)
 int(16)
 int(16)

diff --git a/Zend/tests/closure_019.phpt b/Zend/tests/closure_019.phpt
index 0c4c34e163c5006d5068b911ab823195188c9040..5825ad98ed02789a19be0540111f4ad4b7826704 100644 (file)
--- a/Zend/tests/closure_019.phpt
+++ b/Zend/tests/closure_019.phpt
@@ -20,7 +20,11 @@ test();
 
 ?>
 --EXPECTF--
+
+Notice: Only variable references should be returned by reference in %sclosure_019.php on line 4
 int(9)
+
+Notice: Only variable references should be returned by reference in %sclosure_019.php on line 4
 int(81)
 
 Fatal error: Cannot pass parameter 1 by reference in %s on line %d

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 7132c3e5fc04374a6158386f0ad4fdb13171b494..b390cb7313cd3289637510311e8855f810c5a988 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2717,7 +2717,9 @@ void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
        if (expr) {
                SET_NODE(opline->op1, expr);
 
-               if (do_end_vparse && zend_is_function_or_method_call(expr)) {
+               if (!do_end_vparse) {
+                       opline->extended_value = ZEND_RETURNS_VALUE;
+               } else if (zend_is_function_or_method_call(expr)) {
                        opline->extended_value = ZEND_RETURNS_FUNCTION;
                }
        } else {

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index f9520c98eacf2bb7e7ed52bedce89c92c5dde66f..23c5b22efdba2181169ba61828b0a3d174ba6ad6 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -840,6 +840,7 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC);
 
 #define ZEND_RETURNS_FUNCTION 1<<0
 #define ZEND_RETURNS_NEW      1<<1
+#define ZEND_RETURNS_VALUE    1<<2
 
 #define ZEND_FAST_RET_TO_CATCH         1
 #define ZEND_FAST_RET_TO_FINALLY       2

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 1870c5fcd9cdecf13ceef91f0116d6d3758a56ee..5aea39ea9454135d90434bdff699e010ce726b9f 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -102,16 +102,14 @@ static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
 #define PZVAL_LOCK(z) Z_ADDREF_P((z))
 #define SELECTIVE_PZVAL_LOCK(pzv, opline)      if (RETURN_VALUE_USED(opline)) { PZVAL_LOCK(pzv); }
 
-#define EXTRACT_ZVAL_PTR(t) do {                                               \
-               temp_variable *__t = (t);                                       \
-               if (__t->var.ptr_ptr) {                                         \
-                       __t->var.ptr = *__t->var.ptr_ptr;               \
-                       __t->var.ptr_ptr = &__t->var.ptr;               \
-                       if (!PZVAL_IS_REF(__t->var.ptr) &&              \
-                           Z_REFCOUNT_P(__t->var.ptr) > 2) {   \
-                               SEPARATE_ZVAL(__t->var.ptr_ptr);        \
-                       }                                                                               \
-               }                                                                                       \
+#define EXTRACT_ZVAL_PTR(t) do {                               \
+               temp_variable *__t = (t);                               \
+               __t->var.ptr = *__t->var.ptr_ptr;               \
+               __t->var.ptr_ptr = &__t->var.ptr;               \
+               if (!PZVAL_IS_REF(__t->var.ptr) &&              \
+                   Z_REFCOUNT_P(__t->var.ptr) > 2) {   \
+                       SEPARATE_ZVAL(__t->var.ptr_ptr);        \
+               }                                                                               \
        } while (0)
 
 #define AI_SET_PTR(t, val) do {                                \
@@ -1215,12 +1213,12 @@ convert_to_array:
                                                        zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ce->name);
                                                }
                                        }
-                                       retval = &overloaded_result;
+                                       AI_SET_PTR(result, overloaded_result);
+                                       PZVAL_LOCK(overloaded_result);
                                } else {
-                                       retval = &EG(error_zval_ptr);
+                                       result->var.ptr_ptr = &EG(error_zval_ptr);
+                                       PZVAL_LOCK(EG(error_zval_ptr));
                                }
-                               AI_SET_PTR(result, *retval);
-                               PZVAL_LOCK(*retval);
                                if (dim_type == IS_TMP_VAR) {
                                        zval_ptr_dtor(&dim);
                                }
@@ -1237,8 +1235,8 @@ convert_to_array:
                default:
                        if (type == BP_VAR_UNSET) {
                                zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
-                               AI_SET_PTR(result, &EG(uninitialized_zval));
-                               PZVAL_LOCK(&EG(uninitialized_zval));
+                               result->var.ptr_ptr = &EG(uninitialized_zval_ptr);
+                               PZVAL_LOCK(EG(uninitialized_zval_ptr));
                        } else {
                                zend_error(E_WARNING, "Cannot use a scalar value as an array");
                                result->var.ptr_ptr = &EG(error_zval_ptr);
@@ -1256,12 +1254,12 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
 
                case IS_ARRAY:
                        retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
-                       AI_SET_PTR(result, *retval);
+                       result->var.ptr = *retval;
                        PZVAL_LOCK(*retval);
                        return;
 
                case IS_NULL:
-                       AI_SET_PTR(result, &EG(uninitialized_zval));
+                       result->var.ptr = &EG(uninitialized_zval);
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        return;
 
@@ -1314,7 +1312,7 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
                                        Z_STRVAL_P(ptr)[1] = 0;
                                        Z_STRLEN_P(ptr) = 1;
                                }
-                               AI_SET_PTR(result, ptr);
+                               result->var.ptr = ptr;
                                return;
                        }
                        break;
@@ -1332,12 +1330,14 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
                                }
                                overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
 
-                               if (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));
+                               if (result) {
+                                       if (overloaded_result) {
+                                               result->var.ptr = overloaded_result;
+                                               PZVAL_LOCK(overloaded_result);
+                                       } else {
+                                               result->var.ptr = &EG(uninitialized_zval);
+                                               PZVAL_LOCK(&EG(uninitialized_zval));
+                                       }
                                }
                                if (dim_type == IS_TMP_VAR) {
                                        zval_ptr_dtor(&dim);
@@ -1346,7 +1346,7 @@ static void zend_fetch_dimension_address_read(temp_variable *result, zval *conta
                        return;
 
                default:
-                       AI_SET_PTR(result, &EG(uninitialized_zval));
+                       result->var.ptr = &EG(uninitialized_zval);
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        return;
        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index e95d94d2ffc01840d58c64bc819839f4e82c609b..45cfe909a32f8236faa41f377da6e89565a3797d 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -352,7 +352,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -372,7 +371,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -411,7 +409,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -419,7 +416,6 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -484,7 +480,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                FREE_OP2();
                FREE_OP1_VAR_PTR();
@@ -512,7 +508,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNU
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        FREE_OP2();
 
@@ -805,7 +801,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
        if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                FREE_OP1_VAR_PTR();
                CHECK_EXCEPTION();
@@ -829,7 +825,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        FREE_OP1_VAR_PTR();
@@ -852,7 +848,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
        if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                FREE_OP1_VAR_PTR();
                CHECK_EXCEPTION();
@@ -876,7 +872,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        FREE_OP1_VAR_PTR();
@@ -1106,7 +1102,7 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -1339,7 +1335,7 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                FREE_OP2();
        } else {
                zval *retval;
@@ -1352,7 +1348,7 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (IS_OP2_TMP_FREE()) {
                        zval_ptr_dtor(&offset);
@@ -1461,7 +1457,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                FREE_OP2();
        } else {
                zval *retval;
@@ -1474,7 +1470,7 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (IS_OP2_TMP_FREE()) {
                        zval_ptr_dtor(&offset);
@@ -1579,13 +1575,13 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, CONST|TMP, CONST)
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &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);
 
                PZVAL_LOCK(value);
-               AI_SET_PTR(&EX_T(opline->result.var), value);
+               EX_T(opline->result.var).var.ptr = value;
                FREE_OP2();
        }
        CHECK_EXCEPTION();
@@ -1666,11 +1662,11 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -1678,7 +1674,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -1690,7 +1686,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -1722,11 +1718,11 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (OP1_TYPE == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (IS_OP2_TMP_FREE()) {
@@ -1734,7 +1730,7 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (OP2_TYPE == IS_TMP_VAR) {
@@ -1746,7 +1742,7 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -1803,7 +1799,7 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*variable_ptr_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr);
+               EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
        }
 
        FREE_OP1_VAR_PTR();
@@ -2873,7 +2869,8 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
 
        do {
-               if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
+               if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR || 
+                   (OP1_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
@@ -3495,7 +3492,7 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
        FREE_OP1_IF_VAR();
@@ -3845,7 +3842,6 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
                EX(original_return_value) = EG(return_value_ptr_ptr);
                EG(active_op_array) = new_op_array;
                if (RETURN_VALUE_USED(opline)) {
-                       EX_T(opline->result.var).var.ptr = NULL;
                        EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
                        EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
                } else {
@@ -3883,7 +3879,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
                ALLOC_ZVAL(retval);
                ZVAL_BOOL(retval, failure_retval);
                INIT_PZVAL(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
        }
        ZEND_VM_NEXT_OPCODE();
 }
@@ -4388,7 +4384,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
                Z_ADDREF_PP(value);
        } else {
                PZVAL_LOCK(*value);
-               AI_SET_PTR(&EX_T(opline->result.var), *value);
+               EX_T(opline->result.var).var.ptr = *value;
        }
 
        CHECK_EXCEPTION();

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index f77a2066fd8c2551f2cc2ff2736d6a3636097c7c..107e460c8890b6e5784c8bcf54a3f4370df21a6c 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2417,7 +2417,8 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
        SAVE_OPLINE();
 
        do {
-               if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+               if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
+                   (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
@@ -2608,7 +2609,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
 
@@ -2766,7 +2767,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
                EX(original_return_value) = EG(return_value_ptr_ptr);
                EG(active_op_array) = new_op_array;
                if (RETURN_VALUE_USED(opline)) {
-                       EX_T(opline->result.var).var.ptr = NULL;
                        EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
                        EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
                } else {
@@ -2804,7 +2804,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
                ALLOC_ZVAL(retval);
                ZVAL_BOOL(retval, failure_retval);
                INIT_PZVAL(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
        }
        ZEND_VM_NEXT_OPCODE();
 }
@@ -3482,7 +3482,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -3563,13 +3563,13 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &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);
 
                PZVAL_LOCK(value);
-               AI_SET_PTR(&EX_T(opline->result.var), value);
+               EX_T(opline->result.var).var.ptr = value;
 
        }
        CHECK_EXCEPTION();
@@ -5329,7 +5329,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -6060,7 +6060,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -7683,7 +7683,8 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+               if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
+                   (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
@@ -7875,7 +7876,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
 
@@ -8033,7 +8034,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
                EX(original_return_value) = EG(return_value_ptr_ptr);
                EG(active_op_array) = new_op_array;
                if (RETURN_VALUE_USED(opline)) {
-                       EX_T(opline->result.var).var.ptr = NULL;
                        EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
                        EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
                } else {
@@ -8071,7 +8071,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
                ALLOC_ZVAL(retval);
                ZVAL_BOOL(retval, failure_retval);
                INIT_PZVAL(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
        }
        ZEND_VM_NEXT_OPCODE();
 }
@@ -8801,7 +8801,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -8882,13 +8882,13 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 
        if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &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);
 
                PZVAL_LOCK(value);
-               AI_SET_PTR(&EX_T(opline->result.var), value);
+               EX_T(opline->result.var).var.ptr = value;
 
        }
        CHECK_EXCEPTION();
@@ -10515,7 +10515,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -11248,7 +11248,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -12435,7 +12435,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
                CHECK_EXCEPTION();
@@ -12459,7 +12459,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -12482,7 +12482,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
                CHECK_EXCEPTION();
@@ -12506,7 +12506,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -12850,7 +12850,8 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+               if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
+                   (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
@@ -13152,7 +13153,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
        zval_ptr_dtor_nogc(&free_op1.var);
@@ -13310,7 +13311,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
                EX(original_return_value) = EG(return_value_ptr_ptr);
                EG(active_op_array) = new_op_array;
                if (RETURN_VALUE_USED(opline)) {
-                       EX_T(opline->result.var).var.ptr = NULL;
                        EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
                        EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
                } else {
@@ -13348,7 +13348,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
                ALLOC_ZVAL(retval);
                ZVAL_BOOL(retval, failure_retval);
                INIT_PZVAL(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
        }
        ZEND_VM_NEXT_OPCODE();
 }
@@ -13638,7 +13638,7 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                Z_ADDREF_PP(value);
        } else {
                PZVAL_LOCK(*value);
-               AI_SET_PTR(&EX_T(opline->result.var), *value);
+               EX_T(opline->result.var).var.ptr = *value;
        }
 
        CHECK_EXCEPTION();
@@ -14097,7 +14097,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -14117,7 +14116,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -14156,7 +14154,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -14164,7 +14161,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -14229,7 +14225,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binar
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -14257,7 +14253,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binar
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -14643,7 +14639,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -14875,7 +14871,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -14888,7 +14884,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -14997,7 +14993,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -15010,7 +15006,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -15177,11 +15173,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -15189,7 +15185,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -15201,7 +15197,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -15233,11 +15229,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -15245,7 +15241,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_CONST == IS_TMP_VAR) {
@@ -15257,7 +15253,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -16582,7 +16578,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -16602,7 +16597,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -16641,7 +16635,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -16649,7 +16642,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -16714,7 +16706,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_dtor(free_op2.var);
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -16742,7 +16734,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_dtor(free_op2.var);
 
@@ -17199,7 +17191,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -17212,7 +17204,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -17321,7 +17313,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -17334,7 +17326,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -17502,11 +17494,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -17514,7 +17506,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -17526,7 +17518,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -17558,11 +17550,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (1) {
@@ -17570,7 +17562,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_TMP_VAR == IS_TMP_VAR) {
@@ -17582,7 +17574,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -18649,7 +18641,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -18669,7 +18660,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -18708,7 +18698,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -18716,7 +18705,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -18781,7 +18769,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_ptr_dtor_nogc(&free_op2.var);
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -18809,7 +18797,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_ptr_dtor_nogc(&free_op2.var);
 
@@ -19196,7 +19184,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -19428,7 +19416,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -19441,7 +19429,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -19550,7 +19538,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -19563,7 +19551,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -19731,11 +19719,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -19743,7 +19731,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -19755,7 +19743,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -19787,11 +19775,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -19799,7 +19787,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_VAR == IS_TMP_VAR) {
@@ -19811,7 +19799,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -19868,7 +19856,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*variable_ptr_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr);
+               EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
        }
 
        if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -20821,7 +20809,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -20841,7 +20828,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -20880,7 +20866,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -20888,7 +20873,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -20953,7 +20937,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*bina
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -20981,7 +20965,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*bina
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -21161,7 +21145,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -21347,11 +21331,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -21359,7 +21343,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -21371,7 +21355,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -22243,7 +22227,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -22263,7 +22246,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -22302,7 +22284,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -22310,7 +22291,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -22375,7 +22355,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_o
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
                if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -22403,7 +22383,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_o
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -22859,7 +22839,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -22872,7 +22852,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -22981,7 +22961,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -22994,7 +22974,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -23161,11 +23141,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -23173,7 +23153,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -23185,7 +23165,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -23217,11 +23197,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -23229,7 +23209,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_CV == IS_TMP_VAR) {
@@ -23241,7 +23221,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -23297,7 +23277,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*variable_ptr_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr);
+               EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
        }
 
        if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
@@ -24116,7 +24096,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
 
@@ -24171,7 +24151,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -24191,7 +24170,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -24230,7 +24208,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -24238,7 +24215,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -24302,7 +24278,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*bi
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -24330,7 +24306,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*bi
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -24623,7 +24599,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -24636,7 +24612,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -24743,7 +24719,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -24756,7 +24732,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -25574,7 +25550,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -25594,7 +25569,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -25633,7 +25607,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -25641,7 +25614,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -25705,7 +25677,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*bina
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_dtor(free_op2.var);
 
@@ -25733,7 +25705,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*bina
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_dtor(free_op2.var);
 
@@ -26027,7 +25999,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -26040,7 +26012,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -26147,7 +26119,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -26160,7 +26132,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -26881,7 +26853,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -26901,7 +26872,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -26940,7 +26910,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -26948,7 +26917,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -27012,7 +26980,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*bina
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_ptr_dtor_nogc(&free_op2.var);
 
@@ -27040,7 +27008,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*bina
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_ptr_dtor_nogc(&free_op2.var);
 
@@ -27334,7 +27302,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -27347,7 +27315,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -27454,7 +27422,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -27467,7 +27435,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -28189,7 +28157,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -28209,7 +28176,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -28248,7 +28214,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -28256,7 +28221,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -28320,7 +28284,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*b
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -28348,7 +28312,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*b
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -28613,7 +28577,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -28633,7 +28596,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -28672,7 +28634,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -28680,7 +28641,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -28744,7 +28704,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binar
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -28772,7 +28732,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binar
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -29065,7 +29025,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -29078,7 +29038,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -29185,7 +29145,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -29198,7 +29158,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -29933,7 +29893,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
                CHECK_EXCEPTION();
@@ -29957,7 +29917,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        CHECK_EXCEPTION();
@@ -29979,7 +29939,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
                CHECK_EXCEPTION();
@@ -30003,7 +29963,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        CHECK_EXCEPTION();
@@ -30329,7 +30289,8 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
        SAVE_OPLINE();
 
        do {
-               if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+               if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
+                   (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
@@ -30618,7 +30579,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
                        zval_ptr_dtor(&retval);
                } else {
-                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                       EX_T(opline->result.var).var.ptr = retval;
                }
        }
 
@@ -30776,7 +30737,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
                EX(original_return_value) = EG(return_value_ptr_ptr);
                EG(active_op_array) = new_op_array;
                if (RETURN_VALUE_USED(opline)) {
-                       EX_T(opline->result.var).var.ptr = NULL;
                        EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
                        EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
                } else {
@@ -30814,7 +30774,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
                ALLOC_ZVAL(retval);
                ZVAL_BOOL(retval, failure_retval);
                INIT_PZVAL(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
        }
        ZEND_VM_NEXT_OPCODE();
 }
@@ -31429,7 +31389,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -31449,7 +31408,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -31488,7 +31446,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -31496,7 +31453,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -31560,7 +31516,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -31588,7 +31544,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -31974,7 +31930,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -32205,7 +32161,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -32218,7 +32174,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -32325,7 +32281,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -32338,7 +32294,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -32503,11 +32459,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -32515,7 +32471,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -32527,7 +32483,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -32559,11 +32515,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -32571,7 +32527,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_CONST == IS_TMP_VAR) {
@@ -32583,7 +32539,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -33680,7 +33636,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -33700,7 +33655,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -33739,7 +33693,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -33747,7 +33700,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -33811,7 +33763,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_o
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_dtor(free_op2.var);
 
@@ -33839,7 +33791,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_o
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_dtor(free_op2.var);
 
@@ -34295,7 +34247,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -34308,7 +34260,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -34415,7 +34367,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_dtor(free_op2.var);
        } else {
                zval *retval;
@@ -34428,7 +34380,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (1) {
                        zval_ptr_dtor(&offset);
@@ -34594,11 +34546,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -34606,7 +34558,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -34618,7 +34570,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -34650,11 +34602,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (1) {
@@ -34662,7 +34614,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_TMP_VAR == IS_TMP_VAR) {
@@ -34674,7 +34626,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -35610,7 +35562,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -35630,7 +35581,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -35669,7 +35619,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -35677,7 +35626,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -35741,7 +35689,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_o
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
                zval_ptr_dtor_nogc(&free_op2.var);
 
@@ -35769,7 +35717,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_o
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
        zval_ptr_dtor_nogc(&free_op2.var);
 
@@ -36156,7 +36104,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -36387,7 +36335,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -36400,7 +36348,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -36507,7 +36455,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                zval_ptr_dtor_nogc(&free_op2.var);
        } else {
                zval *retval;
@@ -36520,7 +36468,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -36686,11 +36634,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -36698,7 +36646,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -36710,7 +36658,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -36742,11 +36690,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -36754,7 +36702,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_VAR == IS_TMP_VAR) {
@@ -36766,7 +36714,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -36821,7 +36769,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*variable_ptr_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr);
+               EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
        }
 
        if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
@@ -37644,7 +37592,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -37664,7 +37611,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -37703,7 +37649,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -37711,7 +37656,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -37775,7 +37719,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binar
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -37803,7 +37747,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binar
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -37983,7 +37927,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_IS:
-                       AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                       EX_T(opline->result.var).var.ptr = *retval;
                        break;
                case BP_VAR_UNSET: {
                        zend_free_op free_res;
@@ -38168,11 +38112,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -38180,7 +38124,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -38192,7 +38136,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -38919,7 +38863,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                }
        } else {
                /* here we are sure we are dealing with an object */
@@ -38939,7 +38882,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(*zptr);
                                        EX_T(opline->result.var).var.ptr = *zptr;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -38978,7 +38920,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(z);
                                        EX_T(opline->result.var).var.ptr = z;
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                                zval_ptr_dtor(&z);
                        } else {
@@ -38986,7 +38927,6 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                                if (RETURN_VALUE_USED(opline)) {
                                        PZVAL_LOCK(&EG(uninitialized_zval));
                                        EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-                                       EX_T(opline->result.var).var.ptr_ptr = NULL;
                                }
                        }
                }
@@ -39050,7 +38990,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op
        if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
 
 
@@ -39078,7 +39018,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*var_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *var_ptr);
+               EX_T(opline->result.var).var.ptr = *var_ptr;
        }
 
        if (opline->extended_value == ZEND_ASSIGN_DIM) {
@@ -39533,7 +39473,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
            UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
                zend_error(E_NOTICE, "Trying to get property of non-object");
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -39546,7 +39486,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -39653,7 +39593,7 @@ 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)) {
                PZVAL_LOCK(&EG(uninitialized_zval));
-               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
 
        } else {
                zval *retval;
@@ -39666,7 +39606,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
                retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
 
                PZVAL_LOCK(retval);
-               AI_SET_PTR(&EX_T(opline->result.var), retval);
+               EX_T(opline->result.var).var.ptr = retval;
 
                if (0) {
                        zval_ptr_dtor(&offset);
@@ -39831,11 +39771,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
                                        ALLOC_ZVAL(retval);
                                        ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
                                        INIT_PZVAL(retval);
-                                       AI_SET_PTR(&EX_T(opline->result.var), retval);
+                                       EX_T(opline->result.var).var.ptr = retval;
                                }
                        } else if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                        if (IS_TMP_FREE(free_op_data1)) {
@@ -39843,7 +39783,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(&EG(uninitialized_zval));
-                               AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                               EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                        }
                } else {
                        if ((opline+1)->op1_type == IS_TMP_VAR) {
@@ -39855,7 +39795,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
                        }
                        if (RETURN_VALUE_USED(opline)) {
                                PZVAL_LOCK(value);
-                               AI_SET_PTR(&EX_T(opline->result.var), value);
+                               EX_T(opline->result.var).var.ptr = value;
                        }
                }
                FREE_OP_VAR_PTR(free_op_data2);
@@ -39887,11 +39827,11 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                                ALLOC_ZVAL(retval);
                                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                                INIT_PZVAL(retval);
-                               AI_SET_PTR(&EX_T(opline->result.var), retval);
+                               EX_T(opline->result.var).var.ptr = retval;
                        }
                } else if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
                if (0) {
@@ -39899,7 +39839,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(&EG(uninitialized_zval));
-                       AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
+                       EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
                }
        } else {
                if (IS_CV == IS_TMP_VAR) {
@@ -39911,7 +39851,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
                }
                if (RETURN_VALUE_USED(opline)) {
                        PZVAL_LOCK(value);
-                       AI_SET_PTR(&EX_T(opline->result.var), value);
+                       EX_T(opline->result.var).var.ptr = value;
                }
        }
 
@@ -39965,7 +39905,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 
        if (RETURN_VALUE_USED(opline)) {
                PZVAL_LOCK(*variable_ptr_ptr);
-               AI_SET_PTR(&EX_T(opline->result.var), *variable_ptr_ptr);
+               EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
        }