Don't inline "Undefined variable" warning reporting.

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 8e20a12e091a76e6390614dd71b7392c12220fc1..7e0e5a715c709535baf4f00aa749fb444a68fad9 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -54,6 +54,8 @@ typedef int (ZEND_FASTCALL *incdec_t)(zval *);
 
 #define get_zval_ptr(op_type, node, ex, should_free, type) _get_zval_ptr(op_type, node, ex, should_free, type)
 #define get_zval_ptr_deref(op_type, node, ex, should_free, type) _get_zval_ptr_deref(op_type, node, ex, should_free, type)
+#define get_zval_ptr_r(op_type, node, ex, should_free) _get_zval_ptr_r(op_type, node, ex, should_free)
+#define get_zval_ptr_r_deref(op_type, node, ex, should_free) _get_zval_ptr_r_deref(op_type, node, ex, should_free)
 #define get_zval_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_undef(op_type, node, ex, should_free, type)
 #define get_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
 #define get_zval_ptr_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type)
@@ -222,6 +224,13 @@ static zend_always_inline zval *_get_zval_ptr_var_deref(uint32_t var, const zend
        return ret;
 }
 
+static zend_never_inline ZEND_COLD void zval_undefined_cv(uint32_t var, const zend_execute_data *execute_data)
+{
+       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
+
+       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+}
+
 static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int type, const zend_execute_data *execute_data)
 {
        zend_string *cv;
@@ -229,15 +238,13 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int
        switch (type) {
                case BP_VAR_R:
                case BP_VAR_UNSET:
-                       cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
-                       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+                       zval_undefined_cv(var, execute_data);
                        /* break missing intentionally */
                case BP_VAR_IS:
                        ptr = &EG(uninitialized_zval);
                        break;
                case BP_VAR_RW:
-                       cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
-                       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+                       zval_undefined_cv(var, execute_data);
                        /* break missing intentionally */
                case BP_VAR_W:
                        ZVAL_NULL(ptr);
@@ -248,26 +255,20 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, uint32_t var, int
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
 {
-       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
-
-       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+       zval_undefined_cv(var, execute_data);
        return &EG(uninitialized_zval);
 }
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
 {
-       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
-
-       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+       zval_undefined_cv(var, execute_data);
        return &EG(uninitialized_zval);
 }
 
 static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, uint32_t var, const zend_execute_data *execute_data)
 {
-       zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
-
        ZVAL_NULL(ptr);
-       zend_error(E_NOTICE, "Undefined variable: %s", ZSTR_VAL(cv));
+       zval_undefined_cv(var, execute_data);
        return ptr;
 }
 
@@ -433,6 +434,27 @@ static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, const
        }
 }
 
+static zend_always_inline zval *_get_zval_ptr_r(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free)
+{
+       if (op_type & (IS_TMP_VAR|IS_VAR)) {
+               if (op_type == IS_TMP_VAR) {
+                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+               } else {
+                       ZEND_ASSERT(op_type == IS_VAR);
+                       return _get_zval_ptr_var(node.var, execute_data, should_free);
+               }
+       } else {
+               *should_free = NULL;
+               if (op_type == IS_CONST) {
+                       return EX_CONSTANT(node);
+               } else if (op_type == IS_CV) {
+                       return _get_zval_ptr_cv_BP_VAR_R(execute_data, node.var);
+               } else {
+                       return NULL;
+               }
+       }
+}
+
 static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
@@ -454,6 +476,27 @@ static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node,
        }
 }
 
+static zend_always_inline zval *_get_zval_ptr_r_deref(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free)
+{
+       if (op_type & (IS_TMP_VAR|IS_VAR)) {
+               if (op_type == IS_TMP_VAR) {
+                       return _get_zval_ptr_tmp(node.var, execute_data, should_free);
+               } else {
+                       ZEND_ASSERT(op_type == IS_VAR);
+                       return _get_zval_ptr_var_deref(node.var, execute_data, should_free);
+               }
+       } else {
+               *should_free = NULL;
+               if (op_type == IS_CONST) {
+                       return EX_CONSTANT(node);
+               } else if (op_type == IS_CV) {
+                       return _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, node.var);
+               } else {
+                       return NULL;
+               }
+       }
+}
+
 static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, const zend_execute_data *execute_data, zend_free_op *should_free, int type)
 {
        if (op_type & (IS_TMP_VAR|IS_VAR)) {
@@ -1045,7 +1088,7 @@ static ZEND_COLD int zend_verify_missing_return_type(zend_function *zf, void **c
 static zend_always_inline void zend_assign_to_object(zval *retval, zval *object, uint32_t object_op_type, zval *property_name, uint32_t property_op_type, int value_type, znode_op value_op, const zend_execute_data *execute_data, void **cache_slot)
 {
        zend_free_op free_value;
-       zval *value = get_zval_ptr(value_type, value_op, execute_data, &free_value, BP_VAR_R);
+       zval *value = get_zval_ptr_r(value_type, value_op, execute_data, &free_value);
        zval tmp;
 
        if (object_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 581f9c74cfb87d15f853cd8b295a7235ec610387..799a66e5ebc825103fcd88b8069ad7a5c776e113 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -719,7 +719,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -785,14 +785,14 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMPVAR|
                                ZVAL_DEREF(container);
                        }
                        if (OP1_TYPE == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, OP2_TYPE);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -2149,7 +2149,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, OP2_TYPE, BP_VAR_W);
                        FREE_OP2();
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -2187,7 +2187,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                                        dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
                                        FREE_OP2();
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -2208,7 +2208,7 @@ ZEND_VM_C_LABEL(assign_dim_convert_to_array):
 ZEND_VM_C_LABEL(assign_dim_clean):
                        dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
                        FREE_OP2();
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 21e726ae5df881bad09baca3d9f2cd58b76458d2..a9cb1e6207f1ddf61f4ebe80d5b451b919c84f82 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -16444,7 +16444,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -16510,14 +16510,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -17342,7 +17342,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -17380,7 +17380,7 @@ try_assign_dim_array:
                                        dim = EX_CONSTANT(opline->op2);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -17401,7 +17401,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = EX_CONSTANT(opline->op2);
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -18614,14 +18614,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -18995,7 +18995,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -19033,7 +19033,7 @@ try_assign_dim_array:
                                        dim = NULL;
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -19054,7 +19054,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = NULL;
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -19613,7 +19613,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -19679,14 +19679,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -20511,7 +20511,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -20549,7 +20549,7 @@ try_assign_dim_array:
                                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -20570,7 +20570,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -21250,7 +21250,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -21316,14 +21316,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_VAR == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -22153,7 +22153,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W);
                        zval_ptr_dtor_nogc(free_op2);
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -22191,7 +22191,7 @@ try_assign_dim_array:
                                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
                                        zval_ptr_dtor_nogc(free_op2);
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -22212,7 +22212,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
                        zval_ptr_dtor_nogc(free_op2);
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -22775,7 +22775,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -22841,14 +22841,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -24632,14 +24632,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -25146,7 +25146,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -25212,14 +25212,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -26613,7 +26613,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -26679,14 +26679,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_UNUSED == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -30272,7 +30272,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -30338,14 +30338,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CONST);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -31495,7 +31495,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -31533,7 +31533,7 @@ try_assign_dim_array:
                                        dim = EX_CONSTANT(opline->op2);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -31554,7 +31554,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = EX_CONSTANT(opline->op2);
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -33680,14 +33680,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_UNUSED);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -34242,7 +34242,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -34280,7 +34280,7 @@ try_assign_dim_array:
                                        dim = NULL;
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -34301,7 +34301,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = NULL;
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -35468,7 +35468,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -35534,14 +35534,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, IS_CV);
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -36466,7 +36466,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W);
 
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -36504,7 +36504,7 @@ try_assign_dim_array:
                                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
 
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -36525,7 +36525,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
 
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
@@ -38105,7 +38105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        }
 
        do {
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                        ZVAL_DEREF(object);
@@ -38171,14 +38171,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SP
                                ZVAL_DEREF(container);
                        }
                        if (IS_CV == IS_UNUSED || EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                zend_binary_assign_op_obj_dim(container, dim, value, UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, binary_op);
                                break;
                        }
                }
 
                zend_fetch_dimension_address_RW(&rv, container, dim, (IS_TMP_VAR|IS_VAR));
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
                var_ptr = Z_INDIRECT(rv);
 
@@ -39109,7 +39109,7 @@ try_assign_dim_array:
                        variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W);
                        zval_ptr_dtor_nogc(free_op2);
                }
-               value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+               value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
@@ -39147,7 +39147,7 @@ try_assign_dim_array:
                                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
                                        offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W);
                                        zval_ptr_dtor_nogc(free_op2);
-                                       value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                                       value = get_zval_ptr_r_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                                        zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
                                        FREE_OP(free_op_data1);
                                }
@@ -39168,7 +39168,7 @@ assign_dim_convert_to_array:
 assign_dim_clean:
                        dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
                        zval_ptr_dtor_nogc(free_op2);
-                       value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+                       value = get_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1);
                        FREE_OP(free_op_data1);
                        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));