Get rid of duplicare FETCH_DIM_* handlers

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index a9fadd10da0c644db5ba8b95fb48292b191f19ad..b5ad5635907aa43cb4532fd6b61ca7ed28cc32a5 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1014,6 +1014,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht
        zend_string *offset_key;
        zend_ulong hval;
 
+try_again:
        if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
                hval = Z_LVAL_P(dim);
 num_index:
@@ -1101,6 +1102,9 @@ str_index:
                        case IS_TRUE:
                                hval = 1;
                                goto num_index;
+                       case IS_REFERENCE:
+                               dim = Z_REFVAL_P(dim);
+                               goto try_again;
                        default:
                                zend_error(E_WARNING, "Illegal offset type");
                                retval = (type == BP_VAR_W || type == BP_VAR_RW) ?
@@ -1118,6 +1122,7 @@ static zend_never_inline zend_long zend_check_string_offset(zval *container, zva
                zend_error_noreturn(E_ERROR, "[] operator not supported for strings");
        }
 
+try_again:
        if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
                switch(Z_TYPE_P(dim)) {
                        case IS_STRING:
@@ -1134,6 +1139,9 @@ static zend_never_inline zend_long zend_check_string_offset(zval *container, zva
                        case IS_TRUE:
                                zend_error(E_NOTICE, "String offset cast occurred");
                                break;
+                       case IS_REFERENCE:
+                               dim = Z_REFVAL_P(dim);
+                               goto try_again;
                        default:
                                zend_error(E_WARNING, "Illegal offset type");
                                break;
@@ -1269,13 +1277,13 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z
 {
        zval *retval;
 
-       ZVAL_DEREF(container);
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
                ZVAL_COPY(result, retval);
        } else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
                zend_long offset;
 
+try_again:
                if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
                        switch(Z_TYPE_P(dim)) {
                                /* case IS_LONG: */
@@ -1295,6 +1303,9 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z
                                                zend_error(E_NOTICE, "String offset cast occurred");
                                        }
                                        break;
+                               case IS_REFERENCE:
+                                       dim = Z_REFVAL_P(dim);
+                                       goto try_again;
                                default:
                                        zend_error(E_WARNING, "Illegal offset type");
                                        break;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 005d78584fa9eb1e7ebe49a8cdf52270bc5b40ae..a653786f755b9798e821058d38383ad80e1d8ea1 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1161,22 +1161,22 @@ ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED|CONST|VAR)
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
 }
 
-ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMP|VAR|CV, CONST|TMPVAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *container;
 
        SAVE_OPLINE();
-       container = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+       container = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
        FREE_OP2();
        FREE_OP1();
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -1189,7 +1189,7 @@ ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1199,7 +1199,7 @@ ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -1212,7 +1212,7 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1222,22 +1222,22 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMP|VAR|CV, CONST|TMPVAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *container;
 
        SAVE_OPLINE();
-       container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+       container = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_IS);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
        FREE_OP2();
        FREE_OP1();
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|CV)
 {
        USE_OPLINE
        zval *container;
@@ -1254,7 +1254,7 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNU
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
                ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
                if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -1264,8 +1264,8 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNU
                if (OP2_TYPE == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = GET_OP1_ZVAL_PTR(BP_VAR_R);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+               container = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
                FREE_OP2();
                FREE_OP1();
        }
@@ -1273,7 +1273,7 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNU
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
+ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -1286,7 +1286,7 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1521,13 +1521,13 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_LIST, CONST|TMP|VAR|CV, CONST)
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
                zend_free_op free_op2;
-               zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+               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);
 
                ZVAL_COPY(EX_VAR(opline->result.var), value);
        } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) &&
                   EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) {
                zval *result = EX_VAR(opline->result.var);
-               zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), BP_VAR_R, result TSRMLS_CC);
+               zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, GET_OP2_ZVAL_PTR(BP_VAR_R), BP_VAR_R, result TSRMLS_CC);
 
                if (retval) {
                        if (result != retval) {
@@ -1566,7 +1566,7 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|CV)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1589,7 +1589,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                zend_free_op free_op2, free_op_data1;
                zval  rv;
                zval *value;
-               zval *dim = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
+               zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
                zval *variable_ptr;
 
                if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 4262329143866bca893eb7ea340fc69e1c309d69..b6ed040c44887c8eccdff45df8d13bcbb8cb5f14 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -5163,72 +5163,6 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = opline->op1.zv;
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = opline->op1.zv;
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = NULL;
-               if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_TMP_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = opline->op1.zv;
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -5728,72 +5662,6 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
        return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = opline->op1.zv;
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = opline->op1.zv;
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = NULL;
-               if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = opline->op1.zv;
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_INIT_USER_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -7152,7 +7020,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN
 
        SAVE_OPLINE();
        container = opline->op1.zv;
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -7167,7 +7035,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 
        SAVE_OPLINE();
        container = opline->op1.zv;
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -7191,7 +7059,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPC
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
                ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
                if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -7202,7 +7070,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPC
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
                container = opline->op1.zv;
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        }
@@ -8127,6 +7995,72 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEN
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = opline->op1.zv;
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = opline->op1.zv;
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *container;
+       zend_free_op free_op1, free_op2;
+
+       SAVE_OPLINE();
+
+       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+               container = NULL;
+               if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) {
+                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+               }
+               ZVAL_DEREF(container);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) {
+                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+               }
+               zval_ptr_dtor_nogc(free_op2);
+
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+               }
+               container = opline->op1.zv;
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -10744,72 +10678,6 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = NULL;
-               if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_TMP_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-               zval_ptr_dtor_nogc(free_op1);
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11107,72 +10975,6 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = NULL;
-               if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-               zval_ptr_dtor_nogc(free_op1);
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11803,7 +11605,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL
 
        SAVE_OPLINE();
        container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        CHECK_EXCEPTION();
@@ -11818,7 +11620,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
 
        SAVE_OPLINE();
        container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        CHECK_EXCEPTION();
@@ -11842,7 +11644,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCOD
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
                ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
                if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -11853,7 +11655,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCOD
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
                container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -12557,6 +12359,72 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       zval_ptr_dtor_nogc(free_op1);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       zval_ptr_dtor_nogc(free_op1);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *container;
+       zend_free_op free_op1, free_op2;
+
+       SAVE_OPLINE();
+
+       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+               container = NULL;
+               if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+               }
+               ZVAL_DEREF(container);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+               }
+               zval_ptr_dtor_nogc(free_op2);
+
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+               }
+               container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+               zval_ptr_dtor_nogc(free_op1);
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -15327,7 +15195,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
        zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
@@ -15388,7 +15256,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
        zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
@@ -15423,7 +15291,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
                if (IS_CONST == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
                zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
                zval_ptr_dtor_nogc(free_op1);
@@ -17197,203 +17065,6 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HA
        }
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-               if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       } else {
-               if (IS_TMP_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-               zval_ptr_dtor_nogc(free_op1);
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *object_ptr;
-
-       SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(object_ptr);
-       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-               zend_free_op free_op2;
-               zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_VAR, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-       } else {
-               zend_free_op free_op2, free_op_data1;
-               zval  rv;
-               zval *value;
-               zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-               zval *variable_ptr;
-
-               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
-                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
-                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
-                       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);
-                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
-                       FREE_OP(free_op_data1);
-               } else {
-                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_TMP_VAR TSRMLS_CC);
-                       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);
-                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-                       variable_ptr = Z_INDIRECT(rv);
-                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
-                               FREE_OP(free_op_data1);
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_NULL(EX_VAR(opline->result.var));
-                               }
-                       } else {
-                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
-                               if ((opline+1)->op1_type == IS_VAR) {
-                                       FREE_OP(free_op_data1);
-                               }
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                       }
-               }
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       /* assign_dim has two opcodes! */
-       CHECK_EXCEPTION();
-       ZEND_VM_INC_OPCODE();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -18058,203 +17729,6 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HA
        }
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       zval_ptr_dtor_nogc(free_op1);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-               if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-               if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-               zval_ptr_dtor_nogc(free_op1);
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *object_ptr;
-
-       SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
-
-       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(object_ptr);
-       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-               zend_free_op free_op2;
-               zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_VAR, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-       } else {
-               zend_free_op free_op2, free_op_data1;
-               zval  rv;
-               zval *value;
-               zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
-               zval *variable_ptr;
-
-               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
-                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
-                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
-                       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);
-                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
-                       FREE_OP(free_op_data1);
-               } else {
-                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_VAR TSRMLS_CC);
-                       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);
-                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-                       variable_ptr = Z_INDIRECT(rv);
-                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
-                               FREE_OP(free_op_data1);
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_NULL(EX_VAR(opline->result.var));
-                               }
-                       } else {
-                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
-                               if ((opline+1)->op1_type == IS_VAR) {
-                                       FREE_OP(free_op_data1);
-                               }
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                       }
-               }
-       }
-       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
-       /* assign_dim has two opcodes! */
-       CHECK_EXCEPTION();
-       ZEND_VM_INC_OPCODE();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -18943,7 +18417,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_O
                if (IS_UNUSED == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+               container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
                zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
                zval_ptr_dtor_nogc(free_op1);
@@ -20070,8 +19544,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        CHECK_EXCEPTION();
@@ -20091,7 +19565,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -20114,7 +19588,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -20131,8 +19605,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op1);
        CHECK_EXCEPTION();
@@ -20156,7 +19630,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
                ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
                if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -20166,8 +19640,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
                if (IS_CV == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
                zval_ptr_dtor_nogc(free_op1);
        }
@@ -20188,7 +19662,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_H
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -20456,7 +19930,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
                zend_free_op free_op_data1;
                zval  rv;
                zval *value;
-               zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+               zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                zval *variable_ptr;
 
                if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
@@ -21530,6 +21004,141 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_
        return zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       zval_ptr_dtor_nogc(free_op1);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       zval_ptr_dtor_nogc(free_op1);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *container;
+       zend_free_op free_op1, free_op2;
+
+       SAVE_OPLINE();
+
+       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+               container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+               if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+               }
+               ZVAL_DEREF(container);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+               }
+               zval_ptr_dtor_nogc(free_op2);
+               if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+               }
+               container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+               zval_ptr_dtor_nogc(free_op1);
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+       if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -21767,6 +21376,68 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HA
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *object_ptr;
+
+       SAVE_OPLINE();
+       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+       if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(object_ptr);
+       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
+               zend_free_op free_op2;
+               zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_VAR, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+       } else {
+               zend_free_op free_op2, free_op_data1;
+               zval  rv;
+               zval *value;
+               zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *variable_ptr;
+
+               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
+                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
+                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
+                       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);
+                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+                       FREE_OP(free_op_data1);
+               } else {
+                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+                       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);
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       variable_ptr = Z_INDIRECT(rv);
+                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+                               FREE_OP(free_op_data1);
+                               if (RETURN_VALUE_USED(opline)) {
+                                       ZVAL_NULL(EX_VAR(opline->result.var));
+                               }
+                       } else {
+                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
+                               if ((opline+1)->op1_type == IS_VAR) {
+                                       FREE_OP(free_op_data1);
+                               }
+                               if (RETURN_VALUE_USED(opline)) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                       }
+               }
+       }
+       if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+       /* assign_dim has two opcodes! */
+       CHECK_EXCEPTION();
+       ZEND_VM_INC_OPCODE();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -29743,7 +29414,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 
@@ -29804,7 +29475,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 
@@ -29839,7 +29510,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
                if (IS_CONST == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 
@@ -31604,203 +31275,6 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAN
        }
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-               if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_TMP_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2), IS_TMP_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *object_ptr;
-
-       SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(object_ptr);
-       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-               zend_free_op free_op2;
-               zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_CV, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-       } else {
-               zend_free_op free_op2, free_op_data1;
-               zval  rv;
-               zval *value;
-               zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2);
-               zval *variable_ptr;
-
-               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
-                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
-                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
-                       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);
-                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
-                       FREE_OP(free_op_data1);
-               } else {
-                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_TMP_VAR TSRMLS_CC);
-                       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);
-                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-                       variable_ptr = Z_INDIRECT(rv);
-                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
-                               FREE_OP(free_op_data1);
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_NULL(EX_VAR(opline->result.var));
-                               }
-                       } else {
-                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
-                               if ((opline+1)->op1_type == IS_VAR) {
-                                       FREE_OP(free_op_data1);
-                               }
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                       }
-               }
-       }
-
-       /* assign_dim has two opcodes! */
-       CHECK_EXCEPTION();
-       ZEND_VM_INC_OPCODE();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -32611,203 +32085,6 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_
        return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval *container;
-       zend_free_op free_op1, free_op2;
-
-       SAVE_OPLINE();
-
-       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
-        }
-               container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-               if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-               }
-               ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-               }
-               zval_ptr_dtor_nogc(free_op2);
-
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
-               }
-               container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *container;
-
-       SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2), IS_VAR TSRMLS_CC);
-       zval_ptr_dtor_nogc(free_op2);
-       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
-               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *object_ptr;
-
-       SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
-               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-       }
-       ZVAL_DEREF(object_ptr);
-       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
-               zend_free_op free_op2;
-               zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
-
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_CV, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
-               zval_ptr_dtor_nogc(free_op2);
-       } else {
-               zend_free_op free_op2, free_op_data1;
-               zval  rv;
-               zval *value;
-               zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2);
-               zval *variable_ptr;
-
-               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
-                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
-                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
-                       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);
-                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
-                       FREE_OP(free_op_data1);
-               } else {
-                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_VAR TSRMLS_CC);
-                       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);
-                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
-                       variable_ptr = Z_INDIRECT(rv);
-                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
-                               FREE_OP(free_op_data1);
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_NULL(EX_VAR(opline->result.var));
-                               }
-                       } else {
-                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
-                               if ((opline+1)->op1_type == IS_VAR) {
-                                       FREE_OP(free_op_data1);
-                               }
-                               if (RETURN_VALUE_USED(opline)) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                       }
-               }
-       }
-
-       /* assign_dim has two opcodes! */
-       CHECK_EXCEPTION();
-       ZEND_VM_INC_OPCODE();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -33787,7 +33064,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP
                if (IS_UNUSED == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
 
@@ -35040,8 +34317,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -35061,7 +34338,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35084,7 +34361,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35101,8 +34378,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
        zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -35126,7 +34403,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
                ZVAL_DEREF(container);
-               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
                if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
                }
@@ -35136,8 +34413,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
                if (IS_CV == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+               container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
        }
@@ -35158,7 +34435,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        ZVAL_DEREF(container);
-       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
        if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -35426,7 +34703,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
                zend_free_op free_op_data1;
                zval  rv;
                zval *value;
-               zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+               zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                zval *variable_ptr;
 
                if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
@@ -36511,6 +35788,141 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_H
        return zend_post_incdec_property_helper_SPEC_CV_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+       zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+
+       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+       zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *container;
+       zend_free_op free_op1, free_op2;
+
+       SAVE_OPLINE();
+
+       if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+        if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+            zend_error_noreturn(E_ERROR, "Cannot use temporary expression in write context");
+        }
+               container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+               if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+                       zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+               }
+               ZVAL_DEREF(container);
+               zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+                       EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+               }
+               zval_ptr_dtor_nogc(free_op2);
+
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+                       zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
+               }
+               container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+               zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *container;
+
+       SAVE_OPLINE();
+       container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+
+       if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(container);
+       zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+       zval_ptr_dtor_nogc(free_op2);
+       if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+               EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -36748,6 +36160,68 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HAN
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *object_ptr;
+
+       SAVE_OPLINE();
+       object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+
+       if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+               zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+       }
+       ZVAL_DEREF(object_ptr);
+       if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
+               zend_free_op free_op2;
+               zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, IS_CV, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC);
+               zval_ptr_dtor_nogc(free_op2);
+       } else {
+               zend_free_op free_op2, free_op_data1;
+               zval  rv;
+               zval *value;
+               zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+               zval *variable_ptr;
+
+               if (UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STRING) &&
+                   EXPECTED(Z_STRLEN_P(object_ptr) != 0)) {
+                       zend_long offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC);
+                       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);
+                       zend_assign_to_string_offset(object_ptr, offset, value, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+                       FREE_OP(free_op_data1);
+               } else {
+                       zend_fetch_dimension_address_W(&rv, object_ptr, dim, (IS_TMP_VAR|IS_VAR) TSRMLS_CC);
+                       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);
+                       ZEND_ASSERT(Z_TYPE(rv) == IS_INDIRECT);
+                       variable_ptr = Z_INDIRECT(rv);
+                       if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
+                               FREE_OP(free_op_data1);
+                               if (RETURN_VALUE_USED(opline)) {
+                                       ZVAL_NULL(EX_VAR(opline->result.var));
+                               }
+                       } else {
+                               value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
+                               if ((opline+1)->op1_type == IS_VAR) {
+                                       FREE_OP(free_op_data1);
+                               }
+                               if (RETURN_VALUE_USED(opline)) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                       }
+               }
+       }
+
+       /* assign_dim has two opcodes! */
+       CHECK_EXCEPTION();
+       ZEND_VM_INC_OPCODE();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -40742,18 +40216,18 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_TMP_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_TMP_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40762,8 +40236,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
        ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
@@ -40827,8 +40301,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40837,8 +40311,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
        ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40902,8 +40376,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40912,8 +40386,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
        ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40967,18 +40441,18 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_TMP_CONST_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_TMP_TMP_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_TMP_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_TMP_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_TMP_CV_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -40987,8 +40461,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
        ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
@@ -41042,18 +40516,18 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -41062,8 +40536,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
@@ -41127,8 +40601,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
-       ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
-       ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -41137,8 +40611,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
-       ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER,
-       ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -42402,8 +41876,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER,
-       ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER,
-       ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER,
+       ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_HANDLER,
+       ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER,
        ZEND_NULL_HANDLER,
@@ -42412,8 +41886,8 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER,
-       ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER,
-       ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
+       ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_HANDLER,
+       ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
        ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,