Improved assignment to "next" element of array ($a[] = ...)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 286d58f53e1cf7265db50067d3b6dc523435205b..08262d155398b74e99ab39c8002f73c0714902bb 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2219,10 +2219,30 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC(
 ZEND_VM_C_LABEL(try_assign_dim_array):
                SEPARATE_ARRAY(object_ptr);
                if (OP2_TYPE == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
+                       if (OP_DATA_TYPE == IS_CV || OP_DATA_TYPE == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               FREE_OP_DATA();
                                zend_cannot_add_element();
                                ZEND_VM_C_GOTO(assign_dim_error);
+                       } else if (OP_DATA_TYPE == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (OP_DATA_TYPE == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       FREE_OP_DATA();
+                               }
+                       } else if (OP_DATA_TYPE == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
@@ -2234,9 +2254,9 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                ZEND_VM_C_GOTO(assign_dim_error);
                        }
+                       value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
+                       value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE);
                }
-               value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
-               value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 38f9885743ccad410e6715a2e816942399663dbc..aae7c6709fa192e077611f2c9da6398e6d05c944 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -23257,7 +23257,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -23269,10 +23269,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -23284,9 +23304,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -23359,10 +23379,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -23374,9 +23414,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -23450,10 +23490,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -23465,9 +23525,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -23529,7 +23589,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -23541,10 +23601,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -23556,9 +23636,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -25547,7 +25627,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-       zend_free_op free_op2;
+       zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -25559,10 +25639,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -25574,9 +25674,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -25649,10 +25749,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -25664,9 +25784,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -25740,10 +25860,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -25755,9 +25895,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -25819,7 +25959,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-       zend_free_op free_op2;
+       zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -25831,10 +25971,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -25846,9 +26006,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -27026,7 +27186,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -27038,10 +27198,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -27053,9 +27233,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -27128,10 +27308,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -27143,9 +27343,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -27219,10 +27419,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -27234,9 +27454,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -27298,7 +27518,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -27310,10 +27530,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -27325,9 +27565,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29280,7 +29520,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -29292,10 +29532,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -29307,9 +29567,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29382,10 +29642,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -29397,9 +29677,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29473,10 +29753,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -29488,9 +29788,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29552,7 +29852,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
        USE_OPLINE
        zend_free_op free_op1;
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -29564,10 +29864,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -29579,9 +29899,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40239,7 +40559,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -40251,10 +40571,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -40266,9 +40606,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40341,10 +40681,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -40356,9 +40716,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40432,10 +40792,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -40447,9 +40827,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40511,7 +40891,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -40523,10 +40903,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CONST == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = RT_CONSTANT(opline, opline->op2);
@@ -40538,9 +40938,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -44004,7 +44404,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        USE_OPLINE
 
        zval *object_ptr;
-       zend_free_op free_op2;
+       zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -44016,10 +44416,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -44031,9 +44451,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -44106,10 +44526,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -44121,9 +44561,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -44197,10 +44637,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -44212,9 +44672,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -44276,7 +44736,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
        USE_OPLINE
 
        zval *object_ptr;
-       zend_free_op free_op2;
+       zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -44288,10 +44748,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
@@ -44303,9 +44783,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -46264,7 +46744,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -46276,10 +46756,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -46291,9 +46791,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -46366,10 +46866,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -46381,9 +46901,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -46457,10 +46977,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -46472,9 +47012,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -46536,7 +47076,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -46548,10 +47088,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_UNUSED == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = NULL;
@@ -46563,9 +47123,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -49561,7 +50121,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -49573,10 +50133,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CONST == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CONST == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CONST == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -49588,9 +50168,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                }
-               value = RT_CONSTANT((opline+1), (opline+1)->op1);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -49663,10 +50243,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_TMP_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_TMP_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_TMP_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -49678,9 +50278,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                }
-               value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -49754,10 +50354,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+                               zval_ptr_dtor_nogc(free_op_data);
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_VAR == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_VAR == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+                                       zval_ptr_dtor_nogc(free_op_data);
+                               }
+                       } else if (IS_VAR == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -49769,9 +50389,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                }
-               value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -49833,7 +50453,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
        USE_OPLINE
 
        zval *object_ptr;
-
+       zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
@@ -49845,10 +50465,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 try_assign_dim_array:
                SEPARATE_ARRAY(object_ptr);
                if (IS_CV == IS_UNUSED) {
-                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval));
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+                               ZVAL_DEREF(value);
+                       }
+                       variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
                        if (UNEXPECTED(variable_ptr == NULL)) {
+
                                zend_cannot_add_element();
                                goto assign_dim_error;
+                       } else if (IS_CV == IS_CV) {
+                               if (Z_REFCOUNTED_P(value)) {
+                                       Z_ADDREF_P(value);
+                               }
+                       } else if (IS_CV == IS_VAR) {
+                               if (value != free_op_data) {
+                                       if (Z_REFCOUNTED_P(value)) {
+                                               Z_ADDREF_P(value);
+                                       }
+
+                               }
+                       } else if (IS_CV == IS_CONST) {
+                               if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
+                                       Z_ADDREF_P(value);
+                               }
                        }
                } else {
                        dim = EX_VAR(opline->op2.var);
@@ -49860,9 +50500,9 @@ try_assign_dim_array:
                        if (UNEXPECTED(variable_ptr == NULL)) {
                                goto assign_dim_error;
                        }
+                       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                }
-               value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }