From 6fadb72c0bf53844d4fccfb04af20fc4554c2189 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Fri, 16 Feb 2018 02:45:31 +0300 Subject: [PATCH] Move exceptional code into "cold" helpers --- Zend/zend_execute.c | 175 ++++++--- Zend/zend_vm_def.h | 151 ++++---- Zend/zend_vm_execute.h | 830 +++++++++++++++-------------------------- 3 files changed, 497 insertions(+), 659 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 5a88518449..80217b72f3 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -1024,7 +1024,7 @@ static zend_always_inline void zend_verify_return_type(zend_function *zf, zval * } } -static ZEND_COLD int zend_verify_missing_return_type(zend_function *zf, void **cache_slot) +static ZEND_COLD int zend_verify_missing_return_type(const zend_function *zf, void **cache_slot) { zend_arg_info *ret_info = zf->common.arg_info - 1; @@ -1046,10 +1046,20 @@ static ZEND_COLD int zend_verify_missing_return_type(zend_function *zf, void **c return 1; } +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_use_object_as_array(void) +{ + zend_throw_error(NULL, "Cannot use object as array"); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_illegal_offset(void) +{ + zend_error(E_WARNING, "Illegal offset type"); +} + static zend_never_inline void zend_assign_to_object_dim(zval *object, zval *dim, zval *value) { if (UNEXPECTED(!Z_OBJ_HT_P(object)->write_dimension)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); return; } @@ -1117,7 +1127,7 @@ try_again: dim = Z_REFVAL_P(dim); goto try_again; default: - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); break; } @@ -1291,6 +1301,14 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_wrong_property_check( zend_tmp_string_release(property_name); } +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_deprecated_function(const zend_function *fbc) +{ + zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", + fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", + fbc->common.scope ? "::" : "", + ZSTR_VAL(fbc->common.function_name)); +} + static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zval *value, zval *result EXECUTE_DATA_DC) { zend_uchar c; @@ -1532,6 +1550,87 @@ static zend_always_inline HashTable *zend_get_target_symbol_table(int fetch_type return ht; } +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_undefined_offset(zend_long lval) +{ + zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, lval); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_undefined_index(const zend_string *offset) +{ + zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset)); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_undefined_method(const zend_class_entry *ce, const zend_string *method) +{ + zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(method)); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_invalid_method_call(zval *object, zval *function_name) +{ + zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_non_static_method_call(const zend_function *fbc) +{ + if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { + zend_error(E_DEPRECATED, + "Non-static method %s::%s() should not be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + } else { + zend_throw_error( + zend_ce_error, + "Non-static method %s::%s() cannot be called statically", + ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + } +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_param_must_be_ref(const zend_function *func, uint32_t arg_num) +{ + zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", + arg_num, + func->common.scope ? ZSTR_VAL(func->common.scope->name) : "", + func->common.scope ? "::" : "", + ZSTR_VAL(func->common.function_name)); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_use_scalar_as_array(void) +{ + zend_error(E_WARNING, "Cannot use a scalar value as an array"); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_cannot_add_element(void) +{ + zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_use_resource_as_offset(const zval *dim) +{ + zend_error(E_NOTICE, "Resource ID#%d used as offset, casting to integer (%d)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim)); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_use_new_element_for_string(void) +{ + zend_throw_error(NULL, "[] operator not supported for strings"); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_modify_property_of_non_object(zval *property) +{ + zend_string *tmp; + zend_string *property_name = zval_get_tmp_string(property, &tmp); + zend_error(E_WARNING, "Attempt to modify property '%s' of non-object", ZSTR_VAL(property_name)); + zend_tmp_string_release(tmp); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_access_undefined_propery_in_overloaded_object(void) +{ + zend_throw_error(NULL, "Cannot access undefined property for object with overloaded property access"); +} + +static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_unsupported_property_reference(void) +{ + zend_error(E_WARNING, "This object doesn't support property references"); +} + static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type EXECUTE_DATA_DC) { zval *retval; @@ -1547,14 +1646,14 @@ num_index: num_undef: switch (type) { case BP_VAR_R: - zend_error(E_NOTICE,"Undefined offset: " ZEND_LONG_FMT, hval); + zend_undefined_offset(hval); /* break missing intentionally */ case BP_VAR_UNSET: case BP_VAR_IS: retval = &EG(uninitialized_zval); break; case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined offset: " ZEND_LONG_FMT, hval); + zend_undefined_offset(hval); retval = zend_hash_index_update(ht, hval, &EG(uninitialized_zval)); break; case BP_VAR_W: @@ -1577,14 +1676,14 @@ str_index: if (UNEXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) { switch (type) { case BP_VAR_R: - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key)); + zend_undefined_index(offset_key); /* break missing intentionally */ case BP_VAR_UNSET: case BP_VAR_IS: retval = &EG(uninitialized_zval); break; case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined index: %s", ZSTR_VAL(offset_key)); + zend_undefined_index(offset_key); /* break missing intentionally */ case BP_VAR_W: ZVAL_NULL(retval); @@ -1595,14 +1694,14 @@ str_index: } else { switch (type) { case BP_VAR_R: - zend_error(E_NOTICE, "Undefined index: %s", ZSTR_VAL(offset_key)); + zend_undefined_index(offset_key); /* break missing intentionally */ case BP_VAR_UNSET: case BP_VAR_IS: retval = &EG(uninitialized_zval); break; case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined index: %s", ZSTR_VAL(offset_key)); + zend_undefined_index(offset_key); retval = zend_hash_update(ht, offset_key, &EG(uninitialized_zval)); break; case BP_VAR_W: @@ -1622,7 +1721,7 @@ str_index: hval = zend_dval_to_lval(Z_DVAL_P(dim)); goto num_index; case IS_RESOURCE: - zend_error(E_NOTICE, "Resource ID#%d used as offset, casting to integer (%d)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim)); + zend_use_resource_as_offset(dim); hval = Z_RES_HANDLE_P(dim); goto num_index; case IS_FALSE: @@ -1635,7 +1734,7 @@ str_index: dim = Z_REFVAL_P(dim); goto try_again; default: - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); retval = (type == BP_VAR_W || type == BP_VAR_RW) ? NULL : &EG(uninitialized_zval); } @@ -1674,7 +1773,7 @@ fetch_from_array: if (dim == NULL) { retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(retval == NULL)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); ZVAL_ERROR(result); return; } @@ -1695,7 +1794,7 @@ fetch_from_array: } if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (dim == NULL) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, type EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -1707,7 +1806,7 @@ fetch_from_array: dim = &EG(uninitialized_zval); } if (!Z_OBJ_HT_P(container)->read_dimension) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); ZVAL_ERROR(result); } else { retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result); @@ -1759,7 +1858,7 @@ fetch_from_array: zend_error(E_WARNING, "Cannot unset offset in a non-array variable"); ZVAL_NULL(result); } else { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); ZVAL_ERROR(result); } } @@ -1829,7 +1928,7 @@ try_string_offset: dim = Z_REFVAL_P(dim); goto try_string_offset; default: - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); break; } @@ -1861,7 +1960,7 @@ try_string_offset: dim = &EG(uninitialized_zval); } if (!Z_OBJ_HT_P(container)->read_dimension) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); ZVAL_NULL(result); } else { retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result); @@ -1939,9 +2038,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c object_init(container); } else { if (container_op_type != IS_VAR || EXPECTED(!Z_ISERROR_P(container))) { - zend_string *property_name = zval_get_string(prop_ptr); - zend_error(E_WARNING, "Attempt to modify property '%s' of non-object", ZSTR_VAL(property_name)); - zend_string_release(property_name); + zend_modify_property_of_non_object(prop_ptr); } ZVAL_ERROR(result); return; @@ -1986,7 +2083,7 @@ use_read_property: ZVAL_UNREF(ptr); } } else { - zend_throw_error(NULL, "Cannot access undefined property for object with overloaded property access"); + zend_access_undefined_propery_in_overloaded_object(); ZVAL_ERROR(result); } } else { @@ -1995,7 +2092,7 @@ use_read_property: } else if (EXPECTED(Z_OBJ_HT_P(container)->read_property)) { goto use_read_property; } else { - zend_error(E_WARNING, "This object doesn't support property references"); + zend_unsupported_property_reference(); ZVAL_ERROR(result); } } @@ -2581,7 +2678,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_string(zend_s } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), ZSTR_VAL(mname)); + zend_undefined_method(called_scope, mname); } zend_string_release(lcname); zend_string_release(mname); @@ -2592,18 +2689,8 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_string(zend_s zend_string_release(mname); if (UNEXPECTED(!(fbc->common.fn_flags & ZEND_ACC_STATIC))) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - return NULL; - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { return NULL; } } @@ -2713,23 +2800,13 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(called_scope->name), Z_STRVAL_P(method)); + zend_undefined_method(called_scope, Z_STR_P(method)); } return NULL; } if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - return NULL; - } - } else { - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { return NULL; } } @@ -2740,7 +2817,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar fbc = Z_OBJ_HT_P(obj)->get_method(&object, Z_STR_P(method), NULL); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(object->ce->name), Z_STRVAL_P(method)); + zend_undefined_method(object->ce, Z_STR_P(method)); } return NULL; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 06be17d86f..c82dcd6115 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -172,6 +172,16 @@ ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HELPER(zend_mod_by_zero_helper, ANY, ANY) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); +} + ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMPVAR|CV, CONST|TMPVAR|CV) { USE_OPLINE @@ -184,10 +194,7 @@ ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMPVAR|CV, CONST|TMPVAR|CV) if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_mod_by_zero_helper); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -765,6 +772,25 @@ ZEND_VM_HELPER(zend_this_not_in_object_context_helper, ANY, ANY) HANDLE_EXCEPTION(); } +ZEND_VM_HELPER(zend_abstract_method_helper, ANY, ANY, zend_function *fbc) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); +} + +ZEND_VM_HELPER(zend_undefined_function_helper, ANY, ANY, zval *function_name) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); + HANDLE_EXCEPTION(); +} + ZEND_VM_HELPER(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, binary_op_type binary_op) { USE_OPLINE @@ -842,7 +868,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): if (OP2_TYPE == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); ZEND_VM_C_GOTO(assign_dim_op_ret_null); } } else { @@ -885,7 +911,7 @@ ZEND_VM_C_LABEL(assign_dim_op_convert_to_array): } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (OP2_TYPE == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -895,7 +921,7 @@ ZEND_VM_C_LABEL(assign_dim_op_convert_to_array): ZEND_VM_C_GOTO(assign_dim_op_convert_to_array); } else { if (UNEXPECTED(OP1_TYPE != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } ZEND_VM_C_LABEL(assign_dim_op_ret_null): if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -2253,7 +2279,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): if (OP2_TYPE == IS_UNUSED) { 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"); + zend_cannot_add_element(); ZEND_VM_C_GOTO(assign_dim_error); } } else { @@ -2292,7 +2318,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): FREE_OP_DATA(); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (OP2_TYPE == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); FREE_UNFETCHED_OP_DATA(); FREE_OP1_VAR_PTR(); UNDEF_RESULT(); @@ -2308,7 +2334,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): ZEND_VM_C_GOTO(try_assign_dim_array); } else { if (OP1_TYPE != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = GET_OP2_ZVAL_PTR(BP_VAR_R); ZEND_VM_C_LABEL(assign_dim_error): @@ -3078,7 +3104,7 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, if (OP2_TYPE == IS_CONST) { function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); FREE_OP2(); FREE_OP1(); HANDLE_EXCEPTION(); @@ -3110,7 +3136,7 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } FREE_OP2(); FREE_OP1(); @@ -3226,7 +3252,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } FREE_OP2(); HANDLE_EXCEPTION(); @@ -3263,22 +3289,8 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -3316,9 +3328,7 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) function_name = (zval*)RT_CONSTANT(opline, opline->op2); func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper, function_name, function_name); } fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { @@ -3413,9 +3423,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM) if (error) { efree(error); /* This is the only soft error is_callable() can generate */ - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name)); + zend_non_static_method_call(func); if (UNEXPECTED(EG(exception) != NULL)) { FREE_OP2(); HANDLE_EXCEPTION(); @@ -3483,9 +3491,7 @@ ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) func_name++; func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper, function_name, func_name); } } fbc = Z_FUNC_P(func); @@ -3517,9 +3523,7 @@ ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT) fname = GET_OP2_ZVAL_PTR(BP_VAR_R); func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(fname)); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper, function_name, fname); } fbc = Z_FUNC_P(func); CACHE_PTR(opline->result.num, fbc); @@ -3634,10 +3638,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -3698,15 +3699,10 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) EX(call) = call->prev_execute_data; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { - zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_abstract_method_helper, fbc, fbc); } if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -4222,6 +4218,20 @@ ZEND_VM_HOT_HANDLER(65, ZEND_SEND_VAL, CONST|TMPVAR, NUM) ZEND_VM_NEXT_OPCODE(); } +ZEND_VM_HELPER(zend_cannot_pass_by_ref_helper, ANY, ANY) +{ + USE_OPLINE + zval *arg; + uint32_t arg_num = opline->op2.num; + + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); + FREE_UNFETCHED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_UNDEF(arg); + HANDLE_EXCEPTION(); +} + ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, NUM, SPEC(QUICK_ARG)) { USE_OPLINE @@ -4235,12 +4245,7 @@ ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, NUM, SPEC(QUICK_ARG)) } } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { ZEND_VM_C_LABEL(send_val_by_ref): - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); - FREE_UNFETCHED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_UNDEF(arg); - HANDLE_EXCEPTION(); + ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper); } value = GET_OP1_ZVAL_PTR(BP_VAR_R); arg = ZEND_CALL_VAR(EX(call), opline->result.var); @@ -4693,13 +4698,7 @@ ZEND_VM_C_LABEL(send_array): if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { /* By-value send is not allowed -- emit a warning, * but still perform the call. */ - zend_error(E_WARNING, - "Parameter %d to %s%s%s() expected to be a reference, value given", - arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); - + zend_param_must_be_ref(EX(call)->func, arg_num); } } } else { @@ -4726,13 +4725,7 @@ ZEND_VM_C_LABEL(send_array): if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { /* By-value send is not allowed -- emit a warning, * but still perform the call. */ - zend_error(E_WARNING, - "Parameter %d to %s%s%s() expected to be a reference, value given", - arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); - + zend_param_must_be_ref(EX(call)->func, arg_num); } } } else { @@ -4764,11 +4757,7 @@ ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|VAR|CV, NUM) param = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", - opline->op2.num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); + zend_param_must_be_ref(EX(call)->func, opline->op2.num); } ZVAL_COPY(param, arg); @@ -5293,13 +5282,13 @@ ZEND_VM_C_LABEL(num_index): str = ZSTR_EMPTY_ALLOC(); ZEND_VM_C_GOTO(str_index); } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } FREE_OP2(); } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -5666,7 +5655,7 @@ ZEND_VM_C_LABEL(num_index_dim): } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -8903,7 +8892,7 @@ ZEND_VM_C_LABEL(fetch_dim_r_index_slow): ZEND_VM_C_LABEL(fetch_dim_r_index_undef): ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index ad952979b3..256ec2a146 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -425,6 +425,16 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS); static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS); +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -439,6 +449,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_this_not_in_object_context_hel HANDLE_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_abstract_method_helper_SPEC(zend_function *fbc ZEND_OPCODE_HANDLER_ARGS_DC) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_undefined_function_helper_SPEC(zval *function_name ZEND_OPCODE_HANDLER_ARGS_DC) +{ + USE_OPLINE + + SAVE_OPLINE(); + zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); + HANDLE_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) { zend_execute_data *old_execute_data; @@ -730,10 +759,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -810,10 +836,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -874,15 +897,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV EX(call) = call->prev_execute_data; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { - zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_abstract_method_helper_SPEC(fbc ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1001,15 +1019,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV EX(call) = call->prev_execute_data; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { - zend_throw_error(NULL, "Cannot call abstract method %s::%s()", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_abstract_method_helper_SPEC(fbc ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", - fbc->common.scope ? "::" : "", - ZSTR_VAL(fbc->common.function_name)); + zend_deprecated_function(fbc); if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1192,6 +1205,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER( } } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg; + uint32_t arg_num = opline->op2.num; + + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); + FREE_UNFETCHED_OP(opline->op1_type, opline->op1.var); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_UNDEF(arg); + HANDLE_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -1409,13 +1436,7 @@ send_array: if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { /* By-value send is not allowed -- emit a warning, * but still perform the call. */ - zend_error(E_WARNING, - "Parameter %d to %s%s%s() expected to be a reference, value given", - arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); - + zend_param_must_be_ref(EX(call)->func, arg_num); } } } else { @@ -1442,13 +1463,7 @@ send_array: if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) { /* By-value send is not allowed -- emit a warning, * but still perform the call. */ - zend_error(E_WARNING, - "Parameter %d to %s%s%s() expected to be a reference, value given", - arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); - + zend_param_must_be_ref(EX(call)->func, arg_num); } } } else { @@ -2032,9 +2047,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME function_name = (zval*)RT_CONSTANT(opline, opline->op2); func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(function_name ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) { @@ -2122,9 +2135,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CON func_name++; func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(func_name ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } } fbc = Z_FUNC_P(func); @@ -2156,9 +2167,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CO fname = RT_CONSTANT(opline, opline->op2); func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1); if (UNEXPECTED(func == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(fname)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(fname ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } fbc = Z_FUNC_P(func); CACHE_PTR(opline->result.num, fbc); @@ -2991,12 +3000,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER } } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { send_val_by_ref: - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_UNDEF(arg); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } value = RT_CONSTANT(opline, opline->op1); arg = ZEND_CALL_VAR(EX(call), opline->result.var); @@ -3022,12 +3026,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_C } } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { send_val_by_ref: - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); - - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_UNDEF(arg); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } value = RT_CONSTANT(opline, opline->op1); arg = ZEND_CALL_VAR(EX(call), opline->result.var); @@ -3051,11 +3050,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(Z param = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", - opline->op2.num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); + zend_param_must_be_ref(EX(call)->func, opline->op2.num); } ZVAL_COPY(param, arg); @@ -4104,10 +4099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(Z if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -5174,7 +5166,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CO if (IS_CONST == IS_CONST) { function_name = RT_CONSTANT(opline, opline->op2); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -5206,7 +5198,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CO fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -5320,7 +5312,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -5357,22 +5349,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -5420,9 +5398,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS if (error) { efree(error); /* This is the only soft error is_callable() can generate */ - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name)); + zend_non_static_method_call(func); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -5625,13 +5601,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -6284,7 +6260,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -6606,10 +6582,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVAR_HANDLER( if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -7366,7 +7339,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TM if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -7398,7 +7371,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TM fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); @@ -7513,7 +7486,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -7550,22 +7523,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -7613,9 +7572,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV if (error) { efree(error); /* This is the only soft error is_callable() can generate */ - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name)); + zend_non_static_method_call(func); if (UNEXPECTED(EG(exception) != NULL)) { zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -7748,13 +7705,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } zval_ptr_dtor_nogc(free_op2); } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -8002,7 +7959,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -8933,7 +8890,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -8970,22 +8927,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -9214,13 +9157,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -9900,10 +9843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -10658,7 +10598,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV if (IS_CV == IS_CONST) { function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -10690,7 +10630,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -10804,7 +10744,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -10841,22 +10781,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -10904,9 +10830,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H if (error) { efree(error); /* This is the only soft error is_callable() can generate */ - zend_error(E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(func->common.scope->name), ZSTR_VAL(func->common.function_name)); + zend_non_static_method_call(func); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -11038,13 +10962,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -11432,7 +11356,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -13392,10 +13316,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_CONST_HANDLER( if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -14428,7 +14349,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C if (IS_CONST == IS_CONST) { function_name = RT_CONSTANT(opline, opline->op2); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op1); HANDLE_EXCEPTION(); @@ -14460,7 +14381,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op1); @@ -14955,7 +14876,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -15119,10 +15040,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_TMPVAR_HANDLER if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -16030,7 +15948,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op1); HANDLE_EXCEPTION(); @@ -16062,7 +15980,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); zval_ptr_dtor_nogc(free_op1); @@ -16379,7 +16297,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -17343,10 +17261,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_CV_HANDLER(ZEN if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -18040,7 +17955,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C if (IS_CV == IS_CONST) { function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op1); HANDLE_EXCEPTION(); @@ -18072,7 +17987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op1); @@ -18387,7 +18302,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); zval_ptr_dtor_nogc(free_op1); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -18615,12 +18530,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_HANDLER(Z } } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { send_val_by_ref: - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_UNDEF(arg); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC); arg = ZEND_CALL_VAR(EX(call), opline->result.var); @@ -18646,12 +18556,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_T } } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { send_val_by_ref: - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_UNDEF(arg); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC); arg = ZEND_CALL_VAR(EX(call), opline->result.var); @@ -18675,11 +18580,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEN param = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", - opline->op2.num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); + zend_param_must_be_ref(EX(call)->func, opline->op2.num); } ZVAL_COPY(param, arg); @@ -19554,13 +19455,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -19991,13 +19892,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } zval_ptr_dtor_nogc(free_op2); } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -20501,13 +20402,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -20994,13 +20895,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -21938,11 +21839,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEN param = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", - opline->op2.num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); + zend_param_must_be_ref(EX(call)->func, opline->op2.num); } ZVAL_COPY(param, arg); @@ -23042,7 +22939,7 @@ assign_dim_op_new_array: if (IS_CONST == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -23085,7 +22982,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -23095,7 +22992,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -24344,7 +24241,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -24382,7 +24279,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -24398,7 +24295,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -24435,7 +24332,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -24474,7 +24371,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -24490,7 +24387,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -24527,7 +24424,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -24566,7 +24463,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -24582,7 +24479,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -24619,7 +24516,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -24657,7 +24554,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -24673,7 +24570,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -24822,7 +24719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -24859,22 +24756,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -25052,13 +24935,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -25164,7 +25047,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -25472,7 +25355,7 @@ assign_dim_op_new_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -25515,7 +25398,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -25525,7 +25408,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -26779,7 +26662,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -26817,7 +26700,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -26833,7 +26716,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -26870,7 +26753,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -26909,7 +26792,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -26925,7 +26808,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -26962,7 +26845,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -27001,7 +26884,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -27017,7 +26900,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -27054,7 +26937,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -27092,7 +26975,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -27108,7 +26991,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -27201,7 +27084,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -27238,22 +27121,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -27360,13 +27229,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } zval_ptr_dtor_nogc(free_op2); } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -27472,7 +27341,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -28067,7 +27936,7 @@ assign_dim_op_new_array: if (IS_UNUSED == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -28110,7 +27979,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -28120,7 +27989,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -28299,7 +28168,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -28337,7 +28206,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -28353,7 +28222,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -28390,7 +28259,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -28429,7 +28298,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -28445,7 +28314,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -28482,7 +28351,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -28521,7 +28390,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -28537,7 +28406,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -28574,7 +28443,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -28612,7 +28481,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -28628,7 +28497,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -28721,7 +28590,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -28758,22 +28627,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -29002,13 +28857,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -29399,7 +29254,7 @@ assign_dim_op_new_array: if (IS_CV == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -29442,7 +29297,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -29452,7 +29307,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -30701,7 +30556,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -30739,7 +30594,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -30755,7 +30610,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -30792,7 +30647,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -30831,7 +30686,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -30847,7 +30702,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -30884,7 +30739,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -30923,7 +30778,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -30939,7 +30794,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -30976,7 +30831,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -31014,7 +30869,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}; UNDEF_RESULT(); @@ -31030,7 +30885,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_VAR != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -31236,7 +31091,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -31273,22 +31128,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -31395,13 +31236,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -31507,7 +31348,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -33307,7 +33148,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S if (IS_CONST == IS_CONST) { function_name = RT_CONSTANT(opline, opline->op2); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -33339,7 +33180,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -33453,7 +33294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -33490,22 +33331,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -35181,7 +35008,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -35213,7 +35040,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); @@ -35328,7 +35155,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -35365,22 +35192,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -35888,7 +35701,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -35925,22 +35738,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -37702,7 +37501,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C if (IS_CV == IS_CONST) { function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -37734,7 +37533,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -37848,7 +37647,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(ce, Z_STR_P(function_name)); } HANDLE_EXCEPTION(); @@ -37885,22 +37684,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U object = Z_OBJ(EX(This)); ce = object->ce; } else { - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* Allowed for PHP 4 compatibility. */ - zend_error( - E_DEPRECATED, - "Non-static method %s::%s() should not be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } else { - /* An internal function assumes $this is present and won't check that. - * So PHP would crash by allowing the call. */ - zend_throw_error( - zend_ce_error, - "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + zend_non_static_method_call(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } @@ -38987,11 +38772,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND param = ZEND_CALL_VAR(EX(call), opline->result.var); if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", - opline->op2.num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", - EX(call)->func->common.scope ? "::" : "", - ZSTR_VAL(EX(call)->func->common.function_name)); + zend_param_must_be_ref(EX(call)->func, opline->op2.num); } ZVAL_COPY(param, arg); @@ -40040,10 +39821,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -40640,7 +40418,7 @@ assign_dim_op_new_array: if (IS_CONST == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -40683,7 +40461,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -40693,7 +40471,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -42314,7 +42092,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -42352,7 +42130,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -42368,7 +42146,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -42405,7 +42183,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -42444,7 +42222,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -42460,7 +42238,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -42497,7 +42275,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -42536,7 +42314,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -42552,7 +42330,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -42589,7 +42367,7 @@ try_assign_dim_array: if (IS_CONST == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -42627,7 +42405,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CONST == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -42643,7 +42421,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: @@ -42893,7 +42671,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S if (IS_CONST == IS_CONST) { function_name = RT_CONSTANT(opline, opline->op2); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -42925,7 +42703,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -43045,13 +42823,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -43211,7 +42989,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -43919,7 +43697,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -44083,10 +43861,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMPVAR_HANDLER(ZEN if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -44647,7 +44422,7 @@ assign_dim_op_new_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -44690,7 +44465,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -44700,7 +44475,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -46202,7 +45977,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -46240,7 +46015,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -46256,7 +46031,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -46293,7 +46068,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -46332,7 +46107,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -46348,7 +46123,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -46385,7 +46160,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -46424,7 +46199,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -46440,7 +46215,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -46477,7 +46252,7 @@ try_assign_dim_array: if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -46515,7 +46290,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -46531,7 +46306,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); assign_dim_error: @@ -46725,7 +46500,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(free_op2); HANDLE_EXCEPTION(); @@ -46757,7 +46532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } zval_ptr_dtor_nogc(free_op2); @@ -46878,13 +46653,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } zval_ptr_dtor_nogc(free_op2); } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -46990,7 +46765,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -47261,7 +47036,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -48112,7 +47887,7 @@ assign_dim_op_new_array: if (IS_UNUSED == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -48155,7 +47930,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -48165,7 +47940,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -48630,7 +48405,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -48668,7 +48443,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -48684,7 +48459,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -48721,7 +48496,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -48760,7 +48535,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -48776,7 +48551,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -48813,7 +48588,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -48852,7 +48627,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -48868,7 +48643,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -48905,7 +48680,7 @@ try_assign_dim_array: if (IS_UNUSED == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -48943,7 +48718,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -48959,7 +48734,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = NULL; assign_dim_error: @@ -49108,13 +48883,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -49881,10 +49656,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OP if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { result = EX_VAR(opline->result.var); if (UNEXPECTED(Z_LVAL_P(op2) == 0)) { - SAVE_OPLINE(); - zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) { /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */ ZVAL_LONG(result, 0); @@ -50481,7 +50253,7 @@ assign_dim_op_new_array: if (IS_CV == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { @@ -50524,7 +50296,7 @@ assign_dim_op_convert_to_array: } else { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); zend_wrong_string_offset(EXECUTE_DATA_C); @@ -50534,7 +50306,7 @@ assign_dim_op_convert_to_array: goto assign_dim_op_convert_to_array; } else { if (UNEXPECTED(IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(container)))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } assign_dim_op_ret_null: if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -52029,7 +51801,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -52067,7 +51839,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -52083,7 +51855,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -52120,7 +51892,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -52159,7 +51931,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -52175,7 +51947,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -52212,7 +51984,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -52251,7 +52023,7 @@ try_assign_dim_array: zval_ptr_dtor_nogc(free_op_data); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -52267,7 +52039,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -52304,7 +52076,7 @@ try_assign_dim_array: if (IS_CV == IS_UNUSED) { 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"); + zend_cannot_add_element(); goto assign_dim_error; } } else { @@ -52342,7 +52114,7 @@ try_assign_dim_array: } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_CV == IS_UNUSED) { - zend_throw_error(NULL, "[] operator not supported for strings"); + zend_use_new_element_for_string(); UNDEF_RESULT(); @@ -52358,7 +52130,7 @@ try_assign_dim_array: goto try_assign_dim_array; } else { if (IS_CV != IS_VAR || EXPECTED(!Z_ISERROR_P(object_ptr))) { - zend_error(E_WARNING, "Cannot use a scalar value as an array"); + zend_use_scalar_as_array(); } dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -52664,7 +52436,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA if (IS_CV == IS_CONST) { function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC); } - zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object))); + zend_invalid_method_call(object, function_name); HANDLE_EXCEPTION(); @@ -52696,7 +52468,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(obj->ce->name), Z_STRVAL_P(function_name)); + zend_undefined_method(obj->ce, Z_STR_P(function_name)); } @@ -52816,13 +52588,13 @@ num_index: str = ZSTR_EMPTY_ALLOC(); goto str_index; } else { - zend_error(E_WARNING, "Illegal offset type"); + zend_illegal_offset(); zval_ptr_dtor_nogc(expr_ptr); } } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied"); + zend_cannot_add_element(); zval_ptr_dtor_nogc(expr_ptr); } } @@ -52928,7 +52700,7 @@ num_index_dim: } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { - zend_throw_error(NULL, "Cannot use object as array"); + zend_use_object_as_array(); } else { Z_OBJ_HT_P(container)->unset_dimension(container, offset); } @@ -53337,7 +53109,7 @@ fetch_dim_r_index_slow: fetch_dim_r_index_undef: ZVAL_NULL(EX_VAR(opline->result.var)); SAVE_OPLINE(); - zend_error(E_NOTICE, "Undefined offset: " ZEND_LONG_FMT, offset); + zend_undefined_offset(offset); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -- 2.40.0