clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 09:57:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move exceptional code into "cold" helpers

Browse Source
This commit is contained in:
Dmitry Stogov 2018-02-16 02:45:31 +03:00
parent 27908bace1
commit 6fadb72c0b
3 changed files with 497 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
Zend/zend_execute.c
View File

@ -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;
}

151
Zend/zend_vm_def.h
View File

@ -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();
}

830
Zend/zend_vm_execute.h
View File

File diff suppressed because it is too large Load Diff