Move exceptional code into "cold" helpers

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 5a885184497b7f42c299612a259f0e61af38e26d..80217b72f31ce6372a60f3c6b0952ba0cf66d012 100644 (file)
--- 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 06be17d86fe3262d2cd8dcf143fd7f5737f318e5..c82dcd6115b5181f54a531931152472ecb97a5a5 100644 (file)
--- 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 ad952979b3f6ae6632f9db90f44b899ec7f6abd6..256ec2a1462ed9b8e86cbfbf55fc9319a83e0ea4 100644 (file)
--- 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();
 }