From: Dmitry Stogov Date: Tue, 12 Apr 2016 16:36:24 +0000 (+0300) Subject: Optimize ASSIGN_DIM (separate common unspecializeble code into helper functions). X-Git-Tag: php-7.1.0alpha1~329^2~10 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=eaf489ac2b86430822db785a713ae02c8bbad910;p=php Optimize ASSIGN_DIM (separate common unspecializeble code into helper functions). --- diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 5404754cc1..be01bc7fc8 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -1086,35 +1086,14 @@ static ZEND_COLD int zend_verify_missing_return_type(zend_function *zf, void **c return 1; } -static zend_never_inline void zend_assign_to_object_dim(zval *retval, zval *object, zval *property_name, int value_type, znode_op value_op, const zend_execute_data *execute_data) +static zend_never_inline void zend_assign_to_object_dim(zval *object, zval *dim, zval *value) { - zend_free_op free_value; - zval *value = get_zval_ptr_deref(value_type, value_op, execute_data, &free_value, BP_VAR_R); - - /* Note: property_name in this case is really the array index! */ - if (!Z_OBJ_HT_P(object)->write_dimension) { + if (UNEXPECTED(!Z_OBJ_HT_P(object)->write_dimension)) { zend_throw_error(NULL, "Cannot use object as array"); - FREE_OP(free_value); return; } - /* separate our value if necessary */ - if (value_type == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); - } - } - - Z_OBJ_HT_P(object)->write_dimension(object, property_name, value); - - if (retval && EXPECTED(!EG(exception))) { - ZVAL_COPY(retval, value); - } - if (value_type == IS_CONST) { - zval_ptr_dtor_nogc(value); - } else { - FREE_OP(free_value); - } + Z_OBJ_HT_P(object)->write_dimension(object, dim, value); } static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval *property, zval *value, zval *retval, binary_op_type binary_op) @@ -1151,16 +1130,168 @@ static zend_never_inline void zend_binary_assign_op_obj_dim(zval *object, zval * } } -static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *value, zval *result) +static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type) +{ + zend_long offset; + +try_again: + if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { + switch(Z_TYPE_P(dim)) { + case IS_STRING: + if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { + break; + } + if (type != BP_VAR_UNSET) { + zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim)); + } + break; + case IS_DOUBLE: + case IS_NULL: + case IS_FALSE: + 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; + } + + offset = zval_get_long(dim); + } else { + offset = Z_LVAL_P(dim); + } + + return offset; +} + +static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void) +{ + const char *msg = NULL; + const zend_op *opline = EG(current_execute_data)->opline; + const zend_op *end; + uint32_t var; + + switch (opline->opcode) { + case ZEND_ASSIGN_ADD: + case ZEND_ASSIGN_SUB: + case ZEND_ASSIGN_MUL: + case ZEND_ASSIGN_DIV: + case ZEND_ASSIGN_MOD: + case ZEND_ASSIGN_SL: + case ZEND_ASSIGN_SR: + case ZEND_ASSIGN_CONCAT: + case ZEND_ASSIGN_BW_OR: + case ZEND_ASSIGN_BW_AND: + case ZEND_ASSIGN_BW_XOR: + case ZEND_ASSIGN_POW: + msg = "Cannot use assign-op operators with string offsets"; + break; + case ZEND_FETCH_DIM_W: + case ZEND_FETCH_DIM_RW: + case ZEND_FETCH_DIM_FUNC_ARG: + case ZEND_FETCH_DIM_UNSET: + /* TODO: Encode the "reason" into opline->extended_value??? */ + var = opline->result.var; + opline++; + end = EG(current_execute_data)->func->op_array.opcodes + + EG(current_execute_data)->func->op_array.last; + while (opline < end) { + if (opline->op1_type == IS_VAR && opline->op1.var == var) { + switch (opline->opcode) { + case ZEND_ASSIGN_ADD: + case ZEND_ASSIGN_SUB: + case ZEND_ASSIGN_MUL: + case ZEND_ASSIGN_DIV: + case ZEND_ASSIGN_MOD: + case ZEND_ASSIGN_SL: + case ZEND_ASSIGN_SR: + case ZEND_ASSIGN_CONCAT: + case ZEND_ASSIGN_BW_OR: + case ZEND_ASSIGN_BW_AND: + case ZEND_ASSIGN_BW_XOR: + case ZEND_ASSIGN_POW: + if (opline->extended_value == ZEND_ASSIGN_OBJ) { + msg = "Cannot use string offset as an object"; + } else if (opline->extended_value == ZEND_ASSIGN_DIM) { + msg = "Cannot use string offset as an array"; + } else { + msg = "Cannot use assign-op operators with string offsets"; + } + break; + case ZEND_PRE_INC_OBJ: + case ZEND_PRE_DEC_OBJ: + case ZEND_POST_INC_OBJ: + case ZEND_POST_DEC_OBJ: + case ZEND_PRE_INC: + case ZEND_PRE_DEC: + case ZEND_POST_INC: + case ZEND_POST_DEC: + msg = "Cannot increment/decrement string offsets"; + break; + case ZEND_FETCH_DIM_W: + case ZEND_FETCH_DIM_RW: + case ZEND_FETCH_DIM_FUNC_ARG: + case ZEND_FETCH_DIM_UNSET: + case ZEND_ASSIGN_DIM: + msg = "Cannot use string offset as an array"; + break; + case ZEND_FETCH_OBJ_W: + case ZEND_FETCH_OBJ_RW: + case ZEND_FETCH_OBJ_FUNC_ARG: + case ZEND_FETCH_OBJ_UNSET: + case ZEND_ASSIGN_OBJ: + msg = "Cannot use string offset as an object"; + break; + case ZEND_ASSIGN_REF: + case ZEND_ADD_ARRAY_ELEMENT: + case ZEND_INIT_ARRAY: + msg = "Cannot create references to/from string offsets"; + break; + case ZEND_RETURN_BY_REF: + msg = "Cannot return string offsets by reference"; + break; + case ZEND_UNSET_DIM: + case ZEND_UNSET_OBJ: + msg = "Cannot unset string offsets"; + break; + case ZEND_YIELD: + msg = "Cannot yield string offsets by reference"; + break; + case ZEND_SEND_REF: + case ZEND_SEND_VAR_EX: + msg = "Only variables can be passed by reference"; + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + break; + } + if (opline->op2_type == IS_VAR && opline->op2.var == var) { + ZEND_ASSERT(opline->opcode == ZEND_ASSIGN_REF); + msg = "Cannot create references to/from string offsets"; + break; + } + } + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + ZEND_ASSERT(msg != NULL); + zend_throw_error(NULL, msg); +} + +static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result) { zend_string *old_str; zend_uchar c; size_t string_len; + zend_long offset; + offset = zend_check_string_offset(dim, BP_VAR_W); if (offset < (zend_long)(-Z_STRLEN_P(str))) { /* Error on negative offset */ zend_error(E_WARNING, "Illegal string offset: " ZEND_LONG_FMT, offset); - zend_string_release(Z_STR_P(str)); if (result) { ZVAL_NULL(result); } @@ -1182,7 +1313,6 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu if (string_len == 0) { /* Error on empty input string */ zend_error(E_WARNING, "Cannot assign an empty string to a string offset"); - zend_string_release(Z_STR_P(str)); if (result) { ZVAL_NULL(result); } @@ -1193,7 +1323,6 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu offset += (zend_long)Z_STRLEN_P(str); } - old_str = Z_STR_P(str); if ((size_t)offset >= Z_STRLEN_P(str)) { /* Extend string if needed */ zend_long old_len = Z_STRLEN_P(str); @@ -1202,13 +1331,16 @@ static void zend_assign_to_string_offset(zval *str, zend_long offset, zval *valu memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len); Z_STRVAL_P(str)[offset+1] = 0; } else if (!Z_REFCOUNTED_P(str)) { + old_str = Z_STR_P(str); Z_STR_P(str) = zend_string_init(Z_STRVAL_P(str), Z_STRLEN_P(str), 0); Z_TYPE_INFO_P(str) = IS_STRING_EX; + zend_string_release(old_str); + } else { + SEPARATE_STRING(str); } Z_STRVAL_P(str)[offset] = c; - zend_string_release(old_str); if (result) { /* Return the new character */ if (CG(one_char_string)[c]) { @@ -1472,6 +1604,9 @@ str_index: } } else { switch (Z_TYPE_P(dim)) { + case IS_UNDEF: + zval_undefined_cv(EG(current_execute_data)->opline->op2.var, EG(current_execute_data)); + /* break missing intentionally */ case IS_NULL: offset_key = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -1500,169 +1635,14 @@ str_index: return retval; } -static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type) -{ - zend_long offset; - -try_again: - if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) { - switch(Z_TYPE_P(dim)) { - case IS_STRING: - if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) { - break; - } - if (type != BP_VAR_UNSET) { - zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim)); - } - break; - case IS_DOUBLE: - case IS_NULL: - case IS_FALSE: - 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; - } - - offset = zval_get_long(dim); - } else { - offset = Z_LVAL_P(dim); - } - - return offset; -} - -static zend_never_inline ZEND_COLD void zend_wrong_string_offset(void) +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W(HashTable *ht, const zval *dim) { - const char *msg = NULL; - const zend_op *opline = EG(current_execute_data)->opline; - const zend_op *end; - uint32_t var; - - switch (opline->opcode) { - case ZEND_ASSIGN_ADD: - case ZEND_ASSIGN_SUB: - case ZEND_ASSIGN_MUL: - case ZEND_ASSIGN_DIV: - case ZEND_ASSIGN_MOD: - case ZEND_ASSIGN_SL: - case ZEND_ASSIGN_SR: - case ZEND_ASSIGN_CONCAT: - case ZEND_ASSIGN_BW_OR: - case ZEND_ASSIGN_BW_AND: - case ZEND_ASSIGN_BW_XOR: - case ZEND_ASSIGN_POW: - msg = "Cannot use assign-op operators with string offsets"; - break; - case ZEND_FETCH_DIM_W: - case ZEND_FETCH_DIM_RW: - case ZEND_FETCH_DIM_FUNC_ARG: - case ZEND_FETCH_DIM_UNSET: - /* TODO: Encode the "reason" into opline->extended_value??? */ - var = opline->result.var; - opline++; - end = EG(current_execute_data)->func->op_array.opcodes + - EG(current_execute_data)->func->op_array.last; - while (opline < end) { - if (opline->op1_type == IS_VAR && opline->op1.var == var) { - switch (opline->opcode) { - case ZEND_ASSIGN_ADD: - case ZEND_ASSIGN_SUB: - case ZEND_ASSIGN_MUL: - case ZEND_ASSIGN_DIV: - case ZEND_ASSIGN_MOD: - case ZEND_ASSIGN_SL: - case ZEND_ASSIGN_SR: - case ZEND_ASSIGN_CONCAT: - case ZEND_ASSIGN_BW_OR: - case ZEND_ASSIGN_BW_AND: - case ZEND_ASSIGN_BW_XOR: - case ZEND_ASSIGN_POW: - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - msg = "Cannot use string offset as an object"; - } else if (opline->extended_value == ZEND_ASSIGN_DIM) { - msg = "Cannot use string offset as an array"; - } else { - msg = "Cannot use assign-op operators with string offsets"; - } - break; - case ZEND_PRE_INC_OBJ: - case ZEND_PRE_DEC_OBJ: - case ZEND_POST_INC_OBJ: - case ZEND_POST_DEC_OBJ: - case ZEND_PRE_INC: - case ZEND_PRE_DEC: - case ZEND_POST_INC: - case ZEND_POST_DEC: - msg = "Cannot increment/decrement string offsets"; - break; - case ZEND_FETCH_DIM_W: - case ZEND_FETCH_DIM_RW: - case ZEND_FETCH_DIM_FUNC_ARG: - case ZEND_FETCH_DIM_UNSET: - case ZEND_ASSIGN_DIM: - msg = "Cannot use string offset as an array"; - break; - case ZEND_FETCH_OBJ_W: - case ZEND_FETCH_OBJ_RW: - case ZEND_FETCH_OBJ_FUNC_ARG: - case ZEND_FETCH_OBJ_UNSET: - case ZEND_ASSIGN_OBJ: - msg = "Cannot use string offset as an object"; - break; - case ZEND_ASSIGN_REF: - case ZEND_ADD_ARRAY_ELEMENT: - case ZEND_INIT_ARRAY: - msg = "Cannot create references to/from string offsets"; - break; - case ZEND_RETURN_BY_REF: - msg = "Cannot return string offsets by reference"; - break; - case ZEND_UNSET_DIM: - case ZEND_UNSET_OBJ: - msg = "Cannot unset string offsets"; - break; - case ZEND_YIELD: - msg = "Cannot yield string offsets by reference"; - break; - case ZEND_SEND_REF: - case ZEND_SEND_VAR_EX: - msg = "Only variables can be passed by reference"; - break; - EMPTY_SWITCH_DEFAULT_CASE(); - } - break; - } - if (opline->op2_type == IS_VAR && opline->op2.var == var) { - ZEND_ASSERT(opline->opcode == ZEND_ASSIGN_REF); - msg = "Cannot create references to/from string offsets"; - break; - } - } - break; - EMPTY_SWITCH_DEFAULT_CASE(); - } - ZEND_ASSERT(msg != NULL); - zend_throw_error(NULL, msg); + return zend_fetch_dimension_address_inner(ht, dim, IS_TMP_VAR, BP_VAR_W); } -static zend_always_inline zend_long zend_fetch_string_offset(zval *container, zval *dim, int type) +static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_W_CONST(HashTable *ht, const zval *dim) { - zend_long offset = zend_check_string_offset(dim, type); - - if (Z_REFCOUNTED_P(container)) { - if (Z_REFCOUNT_P(container) > 1) { - Z_DELREF_P(container); - zval_copy_ctor_func(container); - } - Z_ADDREF_P(container); - } - return offset; + return zend_fetch_dimension_address_inner(ht, dim, IS_CONST, BP_VAR_W); } static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type) diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 5207386ccf..d3fa56080b 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -929,7 +929,7 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { #define SEPARATE_ARRAY(zv) do { \ zval *_zv = (zv); \ zend_array *_arr = Z_ARR_P(_zv); \ - if (GC_REFCOUNT(_arr) > 1) { \ + if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) { \ if (!Z_IMMUTABLE_P(_zv)) { \ GC_REFCOUNT(_arr)--; \ } \ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 450e935c41..ef7fa64974 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2343,30 +2343,29 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC( if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { ZEND_VM_C_LABEL(try_assign_dim_array): + SEPARATE_ARRAY(object_ptr); if (OP2_TYPE == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + ZEND_VM_C_GOTO(assign_dim_error); } } else { - dim = GET_OP2_ZVAL_PTR(BP_VAR_R); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, OP2_TYPE, BP_VAR_W); - FREE_OP2(); - } - if (UNEXPECTED(variable_ptr == NULL)) { - FREE_UNFETCHED_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); + if (OP2_TYPE == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + ZEND_VM_C_GOTO(assign_dim_error); } + FREE_OP2(); + } + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -2376,10 +2375,24 @@ ZEND_VM_C_LABEL(try_assign_dim_array): } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_free_op free_op2; - zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R); + dim = GET_OP2_ZVAL_PTR(BP_VAR_R); + value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); + + if (OP_DATA_TYPE == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, OP_DATA_TYPE, (opline+1)->op1, execute_data); + if (OP_DATA_TYPE == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + FREE_OP_DATA(); + } FREE_OP2(); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -2389,13 +2402,10 @@ ZEND_VM_C_LABEL(try_assign_dim_array): FREE_OP1_VAR_PTR(); HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = GET_OP2_ZVAL_PTR(BP_VAR_R); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - FREE_OP2(); value = GET_OP_DATA_ZVAL_PTR_DEREF(BP_VAR_R); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + FREE_OP2(); FREE_OP_DATA(); } } else { @@ -2407,11 +2417,11 @@ ZEND_VM_C_LABEL(assign_dim_convert_to_array): } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { ZEND_VM_C_GOTO(assign_dim_convert_to_array); - } else if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - ZEND_VM_C_GOTO(assign_dim_clean); } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -ZEND_VM_C_LABEL(assign_dim_clean): + if (OP1_TYPE != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +ZEND_VM_C_LABEL(assign_dim_error): FREE_UNFETCHED_OP2(); FREE_UNFETCHED_OP_DATA(); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 8dbd5260df..d263527b82 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -18724,30 +18724,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -18757,10 +18756,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zval *property_name = EX_CONSTANT(opline->op2); + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -18770,13 +18783,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -18788,11 +18798,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -18820,30 +18830,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -18853,10 +18862,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -18866,13 +18889,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -18884,11 +18904,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -18916,30 +18936,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -18949,10 +18968,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -18962,13 +18995,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -18980,11 +19010,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -19012,30 +19042,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -19045,10 +19074,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zval *property_name = EX_CONSTANT(opline->op2); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -19058,13 +19101,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -19076,11 +19116,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -20677,30 +20717,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -20710,10 +20749,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zval *property_name = NULL; + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -20723,13 +20776,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -20741,11 +20791,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -20773,30 +20823,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -20806,10 +20855,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -20819,13 +20882,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -20837,11 +20897,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -20869,30 +20929,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -20902,10 +20961,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -20915,13 +20988,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -20933,11 +21003,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -20965,30 +21035,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -20998,10 +21067,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zval *property_name = NULL; + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -21011,13 +21094,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -21029,11 +21109,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -23090,30 +23170,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -23123,10 +23202,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = EX_CONSTANT((opline+1)->op1); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -23136,13 +23229,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -23154,11 +23244,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -23186,30 +23276,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -23219,10 +23308,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -23232,13 +23335,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -23250,11 +23350,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -23282,30 +23382,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -23315,10 +23414,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -23328,13 +23441,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -23346,11 +23456,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -23378,30 +23488,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -23411,10 +23520,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -23424,13 +23547,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -23442,11 +23562,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -25641,30 +25761,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -25674,10 +25793,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -25687,13 +25820,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); } } else { @@ -25705,11 +25835,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -25737,30 +25867,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -25770,10 +25899,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -25783,13 +25926,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -25801,11 +25941,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -25833,30 +25973,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -25866,10 +26005,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -25879,13 +26032,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -25897,11 +26047,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -25929,30 +26079,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -25962,10 +26111,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -25975,13 +26138,10 @@ try_assign_dim_array: if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); } } else { @@ -25993,11 +26153,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_VAR != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -38573,30 +38733,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } else { - value = EX_CONSTANT((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); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -38606,10 +38765,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -38619,13 +38792,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -38637,11 +38807,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -38669,30 +38839,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -38702,10 +38871,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -38715,13 +38898,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -38733,11 +38913,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -38765,30 +38945,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -38798,10 +38977,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -38811,13 +39004,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -38829,11 +39019,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -38861,30 +39051,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CONST == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = EX_CONSTANT(opline->op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CONST, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -38894,10 +39083,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = EX_CONSTANT(opline->op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = EX_CONSTANT(opline->op2); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -38907,13 +39110,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = EX_CONSTANT(opline->op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -38925,11 +39125,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -41658,30 +41858,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -41691,10 +41890,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -41704,13 +41917,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -41722,11 +41932,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -41754,30 +41964,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -41787,10 +41996,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -41800,13 +42023,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -41818,11 +42038,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -41850,30 +42070,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -41883,10 +42102,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -41896,13 +42129,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -41914,11 +42144,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -41946,30 +42176,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = NULL; - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_UNUSED, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -41979,10 +42208,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = NULL; + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -41992,13 +42235,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = NULL; - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -42010,11 +42250,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -44994,30 +45234,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); - if (UNEXPECTED(variable_ptr == NULL)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; - } - } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(variable_ptr == NULL)) { + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + goto assign_dim_error; } } else { - value = EX_CONSTANT((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); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -45027,10 +45266,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = EX_CONSTANT((opline+1)->op1); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -45040,13 +45293,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -45058,11 +45308,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -45090,30 +45340,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -45123,10 +45372,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -45136,13 +45399,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -45154,11 +45414,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -45186,30 +45446,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -45219,10 +45478,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zend_assign_to_object_dim(object_ptr, dim, value); - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -45232,13 +45505,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op_data); } } else { @@ -45250,11 +45520,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -45282,30 +45552,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, IS_CV, BP_VAR_W); - - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + dim = _get_zval_ptr_cv_undef(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -45315,10 +45584,24 @@ try_assign_dim_array: } } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -45328,13 +45611,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + } } else { @@ -45346,11 +45626,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -48631,30 +48911,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = EX_CONSTANT((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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = EX_CONSTANT((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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -48664,10 +48943,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = EX_CONSTANT((opline+1)->op1); + + if (IS_CONST == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CONST, (opline+1)->op1, execute_data); + if (IS_CONST == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -48677,13 +48970,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = EX_CONSTANT((opline+1)->op1); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); } } else { @@ -48695,11 +48985,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -48727,30 +49017,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - 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); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + 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); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -48760,10 +49049,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_TMP_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_TMP_VAR, (opline+1)->op1, execute_data); + if (IS_TMP_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -48773,13 +49076,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_tmp((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -48791,11 +49091,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -48823,30 +49123,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -48856,10 +49155,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_var((opline+1)->op1.var, execute_data, &free_op_data); + + if (IS_VAR == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_VAR, (opline+1)->op1, execute_data); + if (IS_VAR == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + zval_ptr_dtor_nogc(free_op_data); + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -48869,13 +49182,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_var_deref((opline+1)->op1.var, execute_data, &free_op_data); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op_data); } } else { @@ -48887,11 +49197,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -48919,30 +49229,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - SEPARATE_ARRAY(object_ptr); variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), &EG(uninitialized_zval)); if (UNEXPECTED(variable_ptr == NULL)) { zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); - variable_ptr = NULL; + goto assign_dim_error; } } else { dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - SEPARATE_ARRAY(object_ptr); - variable_ptr = zend_fetch_dimension_address_inner(Z_ARRVAL_P(object_ptr), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); - } - if (UNEXPECTED(variable_ptr == NULL)) { - - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim); } - } else { - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); - value = zend_assign_to_variable(variable_ptr, value, IS_CV); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; } + zval_ptr_dtor_nogc(free_op2); + } + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + value = zend_assign_to_variable(variable_ptr, value, IS_CV); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { if (EXPECTED(Z_ISREF_P(object_ptr))) { @@ -48952,10 +49261,24 @@ try_assign_dim_array: } } if (EXPECTED(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); + dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, (opline+1)->op1.var); + + if (IS_CV == IS_CONST && UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + + zend_assign_to_object_dim(object_ptr, dim, value); + + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && EXPECTED(!EG(exception))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } - zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, IS_CV, (opline+1)->op1, execute_data); + if (IS_CV == IS_CONST) { + zval_ptr_dtor_nogc(value); + } else { + + } zval_ptr_dtor_nogc(free_op2); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { @@ -48965,13 +49288,10 @@ try_assign_dim_array: HANDLE_EXCEPTION(); } else { - zend_long offset; - dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); - offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W); - zval_ptr_dtor_nogc(free_op2); value = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, (opline+1)->op1.var); - zend_assign_to_string_offset(object_ptr, offset, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zend_assign_to_string_offset(object_ptr, dim, value, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL)); + zval_ptr_dtor_nogc(free_op2); } } else { @@ -48983,11 +49303,11 @@ assign_dim_convert_to_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { goto assign_dim_convert_to_array; - } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(object_ptr))) { - goto assign_dim_clean; } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); -assign_dim_clean: + if (IS_CV != IS_VAR || UNEXPECTED(!Z_ISERROR_P(object_ptr))) { + zend_error(E_WARNING, "Cannot use a scalar value as an array"); + } +assign_dim_error: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) {