diff --git a/Zend/zend.h b/Zend/zend.h
index 59c10bd60035a..bc252f4706b0c 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -219,12 +219,13 @@ struct _zend_class_entry {
 	uint32_t enum_backing_type;
 	HashTable *backed_enum_table;
 
+	zend_string *doc_comment;
+
 	union {
 		struct {
 			zend_string *filename;
 			uint32_t line_start;
 			uint32_t line_end;
-			zend_string *doc_comment;
 		} user;
 		struct {
 			const struct _zend_function_entry *builtin_functions;
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 2ea905bbf0b34..2a16f24250ebe 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -2859,6 +2859,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend
 	while (ptr->fname) {
 		fname_len = strlen(ptr->fname);
 		internal_function->handler = ptr->handler;
+		internal_function->doc_comment = ptr->doc_comment ? zend_string_init_interned(ptr->doc_comment, strlen(ptr->doc_comment), 1) : NULL;
 		internal_function->function_name = zend_string_init_interned(ptr->fname, fname_len, 1);
 		internal_function->scope = scope;
 		internal_function->prototype = NULL;
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 7583dca6f7814..aa085c70d9bb1 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -39,6 +39,7 @@ typedef struct _zend_function_entry {
 	uint32_t num_args;
 	uint32_t flags;
 	const zend_frameless_function_info *frameless_function_infos;
+	const char *doc_comment;
 } zend_function_entry;
 
 typedef struct _zend_fcall_info {
@@ -74,31 +75,31 @@ typedef struct _zend_fcall_info_cache {
 #define ZEND_FUNCTION(name)				ZEND_NAMED_FUNCTION(zif_##name)
 #define ZEND_METHOD(classname, name)	ZEND_NAMED_FUNCTION(zim_##classname##_##name)
 
-#define ZEND_FENTRY(zend_name, name, arg_info, flags)	{ #zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, NULL },
+#define ZEND_FENTRY(zend_name, name, arg_info, flags)	{ #zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, NULL, NULL },
 
-#define ZEND_RAW_FENTRY(zend_name, name, arg_info, flags, frameless_function_infos)   { zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos },
+#define ZEND_RAW_FENTRY(zend_name, name, arg_info, flags, frameless_function_infos, doc_comment)   { zend_name, name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos, doc_comment },
 
 /* Same as ZEND_NAMED_FE */
-#define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL)
+#define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL, NULL)
 
-#define ZEND_NAMED_FE(zend_name, name, arg_info)	ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL)
-#define ZEND_FE(name, arg_info)						ZEND_RAW_FENTRY(#name, zif_##name, arg_info, 0, NULL)
-#define ZEND_DEP_FE(name, arg_info)                 ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_DEPRECATED, NULL)
-#define ZEND_FALIAS(name, alias, arg_info)			ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, 0, NULL)
-#define ZEND_DEP_FALIAS(name, alias, arg_info)		ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED, NULL)
+#define ZEND_NAMED_FE(zend_name, name, arg_info)	ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0, NULL, NULL)
+#define ZEND_FE(name, arg_info)						ZEND_RAW_FENTRY(#name, zif_##name, arg_info, 0, NULL, NULL)
+#define ZEND_DEP_FE(name, arg_info)                 ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_DEPRECATED, NULL, NULL)
+#define ZEND_FALIAS(name, alias, arg_info)			ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, 0, NULL, NULL)
+#define ZEND_DEP_FALIAS(name, alias, arg_info)		ZEND_RAW_FENTRY(#name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED, NULL, NULL)
 #define ZEND_NAMED_ME(zend_name, name, arg_info, flags)	ZEND_FENTRY(zend_name, name, arg_info, flags)
-#define ZEND_ME(classname, name, arg_info, flags)	ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags, NULL)
-#define ZEND_DEP_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags | ZEND_ACC_DEPRECATED, NULL)
-#define ZEND_ABSTRACT_ME(classname, name, arg_info)	ZEND_RAW_FENTRY(#name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL)
-#define ZEND_ABSTRACT_ME_WITH_FLAGS(classname, name, arg_info, flags)	ZEND_RAW_FENTRY(#name, NULL, arg_info, flags, NULL)
-#define ZEND_MALIAS(classname, name, alias, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##alias, arg_info, flags, NULL)
-#define ZEND_ME_MAPPING(name, func_name, arg_info, flags) ZEND_RAW_FENTRY(#name, zif_##func_name, arg_info, flags, NULL)
-#define ZEND_FRAMELESS_FE(name, arg_info, flags, frameless_function_infos) \
-	{ #name, zif_##name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos },
-
-#define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags)		ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags, NULL)
-
-#define ZEND_NS_RAW_FENTRY(ns, zend_name, name, arg_info, flags)	ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, zend_name), name, arg_info, flags, NULL)
+#define ZEND_ME(classname, name, arg_info, flags)	ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags, NULL, NULL)
+#define ZEND_DEP_ME(classname, name, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##name, arg_info, flags | ZEND_ACC_DEPRECATED, NULL, NULL)
+#define ZEND_ABSTRACT_ME(classname, name, arg_info)	ZEND_RAW_FENTRY(#name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+#define ZEND_ABSTRACT_ME_WITH_FLAGS(classname, name, arg_info, flags)	ZEND_RAW_FENTRY(#name, NULL, arg_info, flags, NULL, NULL)
+#define ZEND_MALIAS(classname, name, alias, arg_info, flags) ZEND_RAW_FENTRY(#name, zim_##classname##_##alias, arg_info, flags, NULL, NULL)
+#define ZEND_ME_MAPPING(name, func_name, arg_info, flags) ZEND_RAW_FENTRY(#name, zif_##func_name, arg_info, flags, NULL, NULL)
+#define ZEND_FRAMELESS_FE(name, arg_info, flags, frameless_function_infos, doc_comment) \
+	{ #name, zif_##name, arg_info, (uint32_t) (sizeof(arg_info)/sizeof(struct _zend_internal_arg_info)-1), flags, frameless_function_infos, doc_comment },
+
+#define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags)		ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags, NULL, NULL)
+
+#define ZEND_NS_RAW_FENTRY(ns, zend_name, name, arg_info, flags)	ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, zend_name), name, arg_info, flags, NULL, NULL)
 /**
  * Note that if you are asserting that a function is compile-time evaluable, you are asserting that
  *
@@ -109,7 +110,7 @@ typedef struct _zend_fcall_info_cache {
  * 4. The function will not take an unreasonable amount of time or memory to compute on code that may be seen in practice.
  *    (e.g. str_repeat is special cased to check the length instead of using this)
  */
-#define ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_COMPILE_TIME_EVAL, NULL)
+#define ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(name, arg_info) ZEND_RAW_FENTRY(#name, zif_##name, arg_info, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 
 /* Same as ZEND_NS_NAMED_FE */
 #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)			ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
@@ -120,7 +121,7 @@ typedef struct _zend_fcall_info_cache {
 #define ZEND_NS_FALIAS(ns, name, alias, arg_info)		ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, 0)
 #define ZEND_NS_DEP_FALIAS(ns, name, alias, arg_info)	ZEND_NS_RAW_FENTRY(ns, #name, zif_##alias, arg_info, ZEND_ACC_DEPRECATED)
 
-#define ZEND_FE_END            { NULL, NULL, NULL, 0, 0, NULL }
+#define ZEND_FE_END            { NULL, NULL, NULL, 0, 0, NULL, NULL }
 
 #define _ZEND_ARG_INFO_FLAGS(pass_by_ref, is_variadic, is_tentative) \
 	(((pass_by_ref) << _ZEND_SEND_MODE_SHIFT) | ((is_variadic) ? _ZEND_IS_VARIADIC_BIT : 0) | ((is_tentative) ? _ZEND_IS_TENTATIVE_BIT : 0))
diff --git a/Zend/zend_builtin_functions_arginfo.h b/Zend/zend_builtin_functions_arginfo.h
index 8715fb32ebc84..20e6f0f9b48a3 100644
--- a/Zend/zend_builtin_functions_arginfo.h
+++ b/Zend/zend_builtin_functions_arginfo.h
@@ -297,10 +297,10 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(func_get_arg, arginfo_func_get_arg)
 	ZEND_FE(func_get_args, arginfo_func_get_args)
 	ZEND_FE(strlen, arginfo_strlen)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strcmp, arginfo_strcmp)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strncmp, arginfo_strncmp)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strcasecmp, arginfo_strcasecmp)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strncasecmp, arginfo_strncasecmp)
+	ZEND_RAW_FENTRY("strcmp", zif_strcmp, arginfo_strcmp, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strncmp", zif_strncmp, arginfo_strncmp, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strcasecmp", zif_strcasecmp, arginfo_strcasecmp, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strncasecmp", zif_strncasecmp, arginfo_strncasecmp, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(error_reporting, arginfo_error_reporting)
 	ZEND_FE(define, arginfo_define)
 	ZEND_FE(defined, arginfo_defined)
@@ -314,17 +314,17 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(get_mangled_object_vars, arginfo_get_mangled_object_vars)
 	ZEND_FE(get_class_methods, arginfo_get_class_methods)
 	ZEND_FE(method_exists, arginfo_method_exists)
-	ZEND_FRAMELESS_FE(property_exists, arginfo_property_exists, 0, frameless_function_infos_property_exists)
-	ZEND_FRAMELESS_FE(class_exists, arginfo_class_exists, 0, frameless_function_infos_class_exists)
+	ZEND_RAW_FENTRY("property_exists", zif_property_exists, arginfo_property_exists, 0, frameless_function_infos_property_exists, NULL)
+	ZEND_RAW_FENTRY("class_exists", zif_class_exists, arginfo_class_exists, 0, frameless_function_infos_class_exists, NULL)
 	ZEND_FE(interface_exists, arginfo_interface_exists)
 	ZEND_FE(trait_exists, arginfo_trait_exists)
 	ZEND_FE(enum_exists, arginfo_enum_exists)
 	ZEND_FE(function_exists, arginfo_function_exists)
 	ZEND_FE(class_alias, arginfo_class_alias)
 	ZEND_FE(get_included_files, arginfo_get_included_files)
-	ZEND_FALIAS(get_required_files, get_included_files, arginfo_get_required_files)
+	ZEND_RAW_FENTRY("get_required_files", zif_get_included_files, arginfo_get_required_files, 0, NULL, NULL)
 	ZEND_FE(trigger_error, arginfo_trigger_error)
-	ZEND_FALIAS(user_error, trigger_error, arginfo_user_error)
+	ZEND_RAW_FENTRY("user_error", zif_trigger_error, arginfo_user_error, 0, NULL, NULL)
 	ZEND_FE(set_error_handler, arginfo_set_error_handler)
 	ZEND_FE(restore_error_handler, arginfo_restore_error_handler)
 	ZEND_FE(set_exception_handler, arginfo_set_exception_handler)
diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index f1b29af7967c9..6f08a7ca49a83 100644
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -365,6 +365,7 @@ static zend_result zend_create_closure_from_callable(zval *return_value, zval *c
 		call.handler = zend_closure_call_magic;
 		call.function_name = mptr->common.function_name;
 		call.scope = mptr->common.scope;
+		call.doc_comment = NULL;
 
 		zend_free_trampoline(mptr);
 		mptr = (zend_function *) &call;
@@ -479,6 +480,7 @@ ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *object) /* {
 			ZEND_ACC_USER_ARG_INFO;
 	}
 	invoke->internal_function.handler = ZEND_MN(Closure___invoke);
+	invoke->internal_function.doc_comment = NULL;
 	invoke->internal_function.module = 0;
 	invoke->internal_function.scope = zend_ce_closure;
 	invoke->internal_function.function_name = ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE);
@@ -864,6 +866,7 @@ void zend_closure_from_frame(zval *return_value, zend_execute_data *call) { /* {
 		trampoline.handler = zend_closure_call_magic;
 		trampoline.function_name = mptr->common.function_name;
 		trampoline.scope = mptr->common.scope;
+		trampoline.doc_comment = NULL;
 		if (trampoline.fn_flags & ZEND_ACC_VARIADIC) {
 			trampoline.arg_info = trampoline_arg_info;
 		}
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 3334851c4f5a5..b52fffec787f2 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2001,9 +2001,8 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, bool nullify_hand
 	zend_hash_init(&ce->constants_table, 8, NULL, NULL, persistent_hashes);
 	zend_hash_init(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes);
 
-	if (ce->type == ZEND_USER_CLASS) {
-		ce->info.user.doc_comment = NULL;
-	}
+	ce->doc_comment = NULL;
+
 	ZEND_MAP_PTR_INIT(ce->static_members_table, NULL);
 	ZEND_MAP_PTR_INIT(ce->mutable_data, NULL);
 
@@ -8278,7 +8277,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 	ce->info.user.line_end = decl->end_lineno;
 
 	if (decl->doc_comment) {
-		ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
+		ce->doc_comment = zend_string_copy(decl->doc_comment);
 	}
 
 	if (UNEXPECTED((decl->flags & ZEND_ACC_ANON_CLASS))) {
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 0917e481bebf4..8efc57163da86 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -464,6 +464,7 @@ struct _zend_op_array {
 	zend_arg_info *arg_info;
 	HashTable *attributes;
 	ZEND_MAP_PTR_DEF(void **, run_time_cache);
+	zend_string *doc_comment;
 	uint32_t T;         /* number of temporary variables */
 	/* END of common elements */
 
@@ -486,7 +487,6 @@ struct _zend_op_array {
 	zend_string *filename;
 	uint32_t line_start;
 	uint32_t line_end;
-	zend_string *doc_comment;
 
 	int last_literal;
 	uint32_t num_dynamic_func_defs;
@@ -522,6 +522,7 @@ typedef struct _zend_internal_function {
 	zend_internal_arg_info *arg_info;
 	HashTable *attributes;
 	ZEND_MAP_PTR_DEF(void **, run_time_cache);
+	zend_string *doc_comment;
 	uint32_t T;         /* number of temporary variables */
 	/* END of common elements */
 
@@ -549,6 +550,7 @@ union _zend_function {
 		zend_arg_info *arg_info;  /* index -1 represents the return value info, if any */
 		HashTable   *attributes;
 		ZEND_MAP_PTR_DEF(void **, run_time_cache);
+		zend_string *doc_comment;
 		uint32_t T;         /* number of temporary variables */
 	} common;
 
diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c
index 58862c1564da2..2c0a9611a3141 100644
--- a/Zend/zend_enum.c
+++ b/Zend/zend_enum.c
@@ -437,6 +437,7 @@ void zend_enum_register_funcs(zend_class_entry *ce)
 	cases_function->handler = zend_enum_cases_func;
 	cases_function->function_name = ZSTR_KNOWN(ZEND_STR_CASES);
 	cases_function->fn_flags = fn_flags;
+	cases_function->doc_comment = NULL;
 	cases_function->arg_info = (zend_internal_arg_info *) (arginfo_class_UnitEnum_cases + 1);
 	zend_enum_register_func(ce, ZEND_STR_CASES, cases_function);
 
@@ -445,6 +446,7 @@ void zend_enum_register_funcs(zend_class_entry *ce)
 		from_function->handler = zend_enum_from_func;
 		from_function->function_name = ZSTR_KNOWN(ZEND_STR_FROM);
 		from_function->fn_flags = fn_flags;
+		from_function->doc_comment = NULL;
 		from_function->num_args = 1;
 		from_function->required_num_args = 1;
 		from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_BackedEnum_from + 1);
@@ -454,6 +456,7 @@ void zend_enum_register_funcs(zend_class_entry *ce)
 		try_from_function->handler = zend_enum_try_from_func;
 		try_from_function->function_name = ZSTR_KNOWN(ZEND_STR_TRYFROM);
 		try_from_function->fn_flags = fn_flags;
+		try_from_function->doc_comment = NULL;
 		try_from_function->num_args = 1;
 		try_from_function->required_num_args = 1;
 		try_from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_BackedEnum_tryFrom + 1);
diff --git a/Zend/zend_enum_arginfo.h b/Zend/zend_enum_arginfo.h
index 204c67b4682e7..64c36ff3c33af 100644
--- a/Zend/zend_enum_arginfo.h
+++ b/Zend/zend_enum_arginfo.h
@@ -14,13 +14,13 @@ ZEND_END_ARG_INFO()
 
 
 static const zend_function_entry class_UnitEnum_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(UnitEnum, cases, arginfo_class_UnitEnum_cases, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("cases", NULL, arginfo_class_UnitEnum_cases, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_BackedEnum_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(BackedEnum, from, arginfo_class_BackedEnum_from, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(BackedEnum, tryFrom, arginfo_class_BackedEnum_tryFrom, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("from", NULL, arginfo_class_BackedEnum_from, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("tryFrom", NULL, arginfo_class_BackedEnum_tryFrom, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/Zend/zend_exceptions_arginfo.h b/Zend/zend_exceptions_arginfo.h
index 9c00cadfc766b..7899877f53046 100644
--- a/Zend/zend_exceptions_arginfo.h
+++ b/Zend/zend_exceptions_arginfo.h
@@ -96,13 +96,13 @@ ZEND_METHOD(ErrorException, __construct);
 ZEND_METHOD(ErrorException, getSeverity);
 
 static const zend_function_entry class_Throwable_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getMessage, arginfo_class_Throwable_getMessage, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getCode, arginfo_class_Throwable_getCode, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getFile, arginfo_class_Throwable_getFile, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getLine, arginfo_class_Throwable_getLine, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getTrace, arginfo_class_Throwable_getTrace, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getPrevious, arginfo_class_Throwable_getPrevious, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Throwable, getTraceAsString, arginfo_class_Throwable_getTraceAsString, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("getMessage", NULL, arginfo_class_Throwable_getMessage, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getCode", NULL, arginfo_class_Throwable_getCode, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getFile", NULL, arginfo_class_Throwable_getFile, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getLine", NULL, arginfo_class_Throwable_getLine, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getTrace", NULL, arginfo_class_Throwable_getTrace, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getPrevious", NULL, arginfo_class_Throwable_getPrevious, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getTraceAsString", NULL, arginfo_class_Throwable_getTraceAsString, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -128,17 +128,17 @@ static const zend_function_entry class_ErrorException_methods[] = {
 };
 
 static const zend_function_entry class_Error_methods[] = {
-	ZEND_MALIAS(Exception, __clone, __clone, arginfo_class_Error___clone, ZEND_ACC_PRIVATE)
-	ZEND_MALIAS(Exception, __construct, __construct, arginfo_class_Error___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Exception, __wakeup, __wakeup, arginfo_class_Error___wakeup, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Exception, getMessage, getMessage, arginfo_class_Error_getMessage, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getCode, getCode, arginfo_class_Error_getCode, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getFile, getFile, arginfo_class_Error_getFile, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getLine, getLine, arginfo_class_Error_getLine, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getTrace, getTrace, arginfo_class_Error_getTrace, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getPrevious, getPrevious, arginfo_class_Error_getPrevious, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, getTraceAsString, getTraceAsString, arginfo_class_Error_getTraceAsString, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Exception, __toString, __toString, arginfo_class_Error___toString, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__clone", zim_Exception___clone, arginfo_class_Error___clone, ZEND_ACC_PRIVATE, NULL, NULL)
+	ZEND_RAW_FENTRY("__construct", zim_Exception___construct, arginfo_class_Error___construct, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__wakeup", zim_Exception___wakeup, arginfo_class_Error___wakeup, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMessage", zim_Exception_getMessage, arginfo_class_Error_getMessage, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getCode", zim_Exception_getCode, arginfo_class_Error_getCode, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getFile", zim_Exception_getFile, arginfo_class_Error_getFile, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getLine", zim_Exception_getLine, arginfo_class_Error_getLine, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getTrace", zim_Exception_getTrace, arginfo_class_Error_getTrace, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getPrevious", zim_Exception_getPrevious, arginfo_class_Error_getPrevious, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getTraceAsString", zim_Exception_getTraceAsString, arginfo_class_Error_getTraceAsString, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("__toString", zim_Exception___toString, arginfo_class_Error___toString, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 73f7a03c33952..52a55d218393b 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -149,6 +149,7 @@ ZEND_API const zend_internal_function zend_pass_function = {
 	(zend_internal_arg_info *) zend_pass_function_arg_info + 1, /* arg_info */
 	NULL,                   /* attributes        */
 	NULL,                   /* run_time_cache    */
+	NULL,                   /* doc_comment       */
 	0,                      /* T                 */
 	ZEND_FN(pass),          /* handler           */
 	NULL,                   /* module            */
diff --git a/Zend/zend_interfaces_arginfo.h b/Zend/zend_interfaces_arginfo.h
index 66ad16269293b..bcdc8dd87c473 100644
--- a/Zend/zend_interfaces_arginfo.h
+++ b/Zend/zend_interfaces_arginfo.h
@@ -74,40 +74,40 @@ static const zend_function_entry class_Traversable_methods[] = {
 };
 
 static const zend_function_entry class_IteratorAggregate_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(IteratorAggregate, getIterator, arginfo_class_IteratorAggregate_getIterator, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("getIterator", NULL, arginfo_class_IteratorAggregate_getIterator, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Iterator_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Iterator, current, arginfo_class_Iterator_current, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Iterator, next, arginfo_class_Iterator_next, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Iterator, key, arginfo_class_Iterator_key, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Iterator, valid, arginfo_class_Iterator_valid, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Iterator, rewind, arginfo_class_Iterator_rewind, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("current", NULL, arginfo_class_Iterator_current, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("next", NULL, arginfo_class_Iterator_next, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("key", NULL, arginfo_class_Iterator_key, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("valid", NULL, arginfo_class_Iterator_valid, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("rewind", NULL, arginfo_class_Iterator_rewind, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_ArrayAccess_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(ArrayAccess, offsetExists, arginfo_class_ArrayAccess_offsetExists, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(ArrayAccess, offsetGet, arginfo_class_ArrayAccess_offsetGet, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(ArrayAccess, offsetSet, arginfo_class_ArrayAccess_offsetSet, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(ArrayAccess, offsetUnset, arginfo_class_ArrayAccess_offsetUnset, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("offsetExists", NULL, arginfo_class_ArrayAccess_offsetExists, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetGet", NULL, arginfo_class_ArrayAccess_offsetGet, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetSet", NULL, arginfo_class_ArrayAccess_offsetSet, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetUnset", NULL, arginfo_class_ArrayAccess_offsetUnset, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Serializable_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Serializable, serialize, arginfo_class_Serializable_serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Serializable, unserialize, arginfo_class_Serializable_unserialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("serialize", NULL, arginfo_class_Serializable_serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("unserialize", NULL, arginfo_class_Serializable_unserialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Countable_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Countable, count, arginfo_class_Countable_count, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("count", NULL, arginfo_class_Countable_count, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Stringable_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Stringable, __toString, arginfo_class_Stringable___toString, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("__toString", NULL, arginfo_class_Stringable___toString, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 7e6c232cc459f..8828a03d7b618 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -163,6 +163,11 @@ ZEND_API void zend_function_dtor(zval *zv)
 			}
 		}
 
+		if (function->common.doc_comment) {
+			zend_string_release_ex(function->common.doc_comment, 1);
+			function->common.doc_comment = NULL;
+		}
+
 		if (!(function->common.fn_flags & ZEND_ACC_ARENA_ALLOCATED)) {
 			pefree(function, 1);
 		}
@@ -337,8 +342,8 @@ ZEND_API void destroy_zend_class(zval *zv)
 				zend_string_release_ex(ce->name, 0);
 				zend_string_release_ex(ce->info.user.filename, 0);
 
-				if (ce->info.user.doc_comment) {
-					zend_string_release_ex(ce->info.user.doc_comment, 0);
+				if (ce->doc_comment) {
+					zend_string_release_ex(ce->doc_comment, 0);
 				}
 
 				if (ce->attributes) {
@@ -419,6 +424,10 @@ ZEND_API void destroy_zend_class(zval *zv)
 			}
 			break;
 		case ZEND_INTERNAL_CLASS:
+			if (ce->doc_comment) {
+				zend_string_release_ex(ce->doc_comment, 1);
+			}
+
 			if (ce->backed_enum_table) {
 				zend_hash_release(ce->backed_enum_table);
 			}
diff --git a/build/gen_stub.php b/build/gen_stub.php
index 5e1dfad0bb870..2aa3bec719914 100755
--- a/build/gen_stub.php
+++ b/build/gen_stub.php
@@ -24,7 +24,15 @@
 const PHP_81_VERSION_ID = 80100;
 const PHP_82_VERSION_ID = 80200;
 const PHP_83_VERSION_ID = 80300;
-const ALL_PHP_VERSION_IDS = [PHP_70_VERSION_ID, PHP_80_VERSION_ID, PHP_81_VERSION_ID, PHP_82_VERSION_ID, PHP_83_VERSION_ID];
+const PHP_84_VERSION_ID = 80400;
+const ALL_PHP_VERSION_IDS = [
+    PHP_70_VERSION_ID,
+    PHP_80_VERSION_ID,
+    PHP_81_VERSION_ID,
+    PHP_82_VERSION_ID,
+    PHP_83_VERSION_ID,
+    PHP_84_VERSION_ID,
+];
 
 /**
  * @return FileInfo[]
@@ -1220,13 +1228,17 @@ class FuncInfo {
     public int $numRequiredArgs;
     public ?string $cond;
     public bool $isUndocumentable;
+    public ?int $minimumPhpVersionIdCompatibility;
     /** @var AttributeInfo[] */
     public array $attributes;
+    /** @var FramelessFunctionInfo[] */
     public array $framelessFunctionInfos;
+    public ?ExposedDocComment $exposedDocComment;
 
     /**
-     * @param AttributeInfo[] $attributes
      * @param ArgInfo[] $args
+     * @param AttributeInfo[] $attribute
+     * @param FramelessFunctionInfo[] $framelessFunctionInfos
      */
     public function __construct(
         FunctionOrMethodName $name,
@@ -1242,8 +1254,10 @@ public function __construct(
         int $numRequiredArgs,
         ?string $cond,
         bool $isUndocumentable,
+        ?int $minimumPhpVersionIdCompatibility,
         array $attributes,
-        array $framelessFunctionInfos
+        array $framelessFunctionInfos,
+        ?ExposedDocComment $exposedDocComment
     ) {
         $this->name = $name;
         $this->classFlags = $classFlags;
@@ -1258,8 +1272,10 @@ public function __construct(
         $this->numRequiredArgs = $numRequiredArgs;
         $this->cond = $cond;
         $this->isUndocumentable = $isUndocumentable;
+        $this->minimumPhpVersionIdCompatibility = $minimumPhpVersionIdCompatibility;
         $this->attributes = $attributes;
         $this->framelessFunctionInfos = $framelessFunctionInfos;
+        $this->exposedDocComment = $exposedDocComment;
     }
 
     public function isMethod(): bool
@@ -1361,7 +1377,14 @@ public function getFramelessDeclaration(FuncInfo $funcInfo): ?string {
             return null;
         }
 
+        $php84MinimumCompatibility = $this->minimumPhpVersionIdCompatibility === null || $this->minimumPhpVersionIdCompatibility >= PHP_84_VERSION_ID;
+
         $code = '';
+
+        if (!$php84MinimumCompatibility) {
+            $code .= "#if (PHP_VERSION_ID >= " . PHP_84_VERSION_ID . ")\n";
+        }
+
         foreach ($this->framelessFunctionInfos as $framelessFunctionInfo) {
             $code .= "ZEND_FRAMELESS_FUNCTION({$this->name->getFunctionName()}, {$framelessFunctionInfo->arity});\n";
         }
@@ -1372,6 +1395,11 @@ public function getFramelessDeclaration(FuncInfo $funcInfo): ?string {
         }
         $code .= "\t{ 0 },\n";
         $code .= "};\n";
+
+        if (!$php84MinimumCompatibility) {
+            $code .= "#endif\n";
+        }
+
         return $code;
     }
 
@@ -1380,94 +1408,107 @@ public function getFramelessFunctionInfosName(): string {
     }
 
     public function getFunctionEntry(): string {
-        if ($this->name instanceof MethodName) {
+        $code = "";
+
+        $php84MinimumCompatibility = $this->minimumPhpVersionIdCompatibility === null || $this->minimumPhpVersionIdCompatibility >= PHP_84_VERSION_ID;
+        $isVanillaEntry = $this->alias === null && !$this->supportsCompileTimeEval && $this->exposedDocComment === null && empty($this->framelessFunctionInfos);
+        $argInfoName = $this->getArgInfoName();
+        $flagsByPhpVersions = $this->getArginfoFlagsByPhpVersions();
+        $functionEntryCode = null;
+
+        if (!empty($this->framelessFunctionInfos)) {
+            if ($this->isMethod()) {
+                throw new Exception('Frameless methods are not supported yet');
+            }
+            if ($this->name->getNamespace()) {
+                throw new Exception('Namespaced direct calls to frameless functions are not supported yet');
+            }
+            if ($this->alias) {
+                throw new Exception('Aliased direct calls to frameless functions are not supported yet');
+            }
+        }
+
+        if ($this->isMethod()) {
+            $zendName = '"' . $this->name->methodName . '"';
             if ($this->alias) {
                 if ($this->alias instanceof MethodName) {
-                    return sprintf(
-                        "\tZEND_MALIAS(%s, %s, %s, %s, %s)\n",
-                        $this->alias->getDeclarationClassName(), $this->name->methodName,
-                        $this->alias->methodName, $this->getArgInfoName(), $this->getFlagsAsArginfoString()
-                    );
+                    $name = "zim_" . $this->alias->getDeclarationClassName() . "_" . $this->alias->methodName;
                 } else if ($this->alias instanceof FunctionName) {
-                    return sprintf(
-                        "\tZEND_ME_MAPPING(%s, %s, %s, %s)\n",
-                        $this->name->methodName, $this->alias->getNonNamespacedName(),
-                        $this->getArgInfoName(), $this->getFlagsAsArginfoString()
-                    );
+                    $name = "zif_" . $this->alias->getNonNamespacedName();
                 } else {
                     throw new Error("Cannot happen");
                 }
             } else {
-                $declarationClassName = $this->name->getDeclarationClassName();
                 if ($this->flags & Modifiers::ABSTRACT) {
-                    return sprintf(
-                        "\tZEND_ABSTRACT_ME_WITH_FLAGS(%s, %s, %s, %s)\n",
-                        $declarationClassName, $this->name->methodName, $this->getArgInfoName(),
-                        $this->getFlagsAsArginfoString()
-                    );
-                }
+                    $name = "NULL";
+                } else {
+                    $name = "zim_" . $this->name->getDeclarationClassName() . "_" . $this->name->methodName;
 
-                return sprintf(
-                    "\tZEND_ME(%s, %s, %s, %s)\n",
-                    $declarationClassName, $this->name->methodName, $this->getArgInfoName(),
-                    $this->getFlagsAsArginfoString()
-                );
+                    if ($isVanillaEntry) {
+                        $functionEntryCode = "\tZEND_ME(" . $this->name->getDeclarationClassName() . ", " . $this->name->methodName . ", $argInfoName, " . implode("|", reset($flagsByPhpVersions)) . ")";
+                    }
+                }
             }
         } else if ($this->name instanceof FunctionName) {
-            $namespace = $this->name->getNamespace();
             $functionName = $this->name->getFunctionName();
             $declarationName = $this->alias ? $this->alias->getNonNamespacedName() : $this->name->getDeclarationName();
 
-            if (!empty($this->framelessFunctionInfos)) {
-                if ($namespace) {
-                    die('Namespaced direct calls are not supported yet');
-                }
-                if ($this->alias) {
-                    die('Aliased direct calls are not supported yet');
+            if ($this->name->getNamespace()) {
+                $namespace = addslashes($this->name->getNamespace());
+                $zendName = "ZEND_NS_NAME(\"$namespace\", \"$functionName\")";
+                $name = "zif_$declarationName";
+            } else {
+                $zendName = '"' . $functionName . '"';
+                $name = "zif_$declarationName";
+
+                if ($isVanillaEntry && reset($flagsByPhpVersions) === ["0"]) {
+                    $functionEntryCode = "\tZEND_FE($declarationName, $argInfoName)";
                 }
-                $flags = $this->supportsCompileTimeEval ? 'ZEND_ACC_COMPILE_TIME_EVAL' : '0';
-                return sprintf(
-                    "\tZEND_FRAMELESS_FE(%s, %s, %s, %s)\n",
-                    $functionName, $this->getArgInfoName(), $flags, $this->getFramelessFunctionInfosName()
-                );
             }
+        } else {
+            throw new Error("Cannot happen");
+        }
 
-            if ($namespace) {
-                // Namespaced functions are always declared as aliases to avoid name conflicts when two functions with
-                // the same name exist in separate namespaces
-                $macro = $this->isDeprecated ? 'ZEND_NS_DEP_FALIAS' : 'ZEND_NS_FALIAS';
-
-                // Render A\B as "A\\B" in C strings for namespaces
-                return sprintf(
-                    "\t%s(\"%s\", %s, %s, %s)\n",
-                    $macro, addslashes($namespace), $this->name->getFunctionName(), $declarationName, $this->getArgInfoName()
-                );
+        if ($functionEntryCode !== null) {
+            $code .= "$functionEntryCode\n";
+        } else {
+            if (!$php84MinimumCompatibility) {
+                $code .= "#if (PHP_VERSION_ID >= " . PHP_84_VERSION_ID . ")\n";
             }
 
-            if ($this->alias) {
-                $macro = $this->isDeprecated ? 'ZEND_DEP_FALIAS' : 'ZEND_FALIAS';
+            $php84AndAboveFlags = array_slice($flagsByPhpVersions, 5, null, true);
+            $docComment = $this->exposedDocComment ? '"' . $this->exposedDocComment->escape() . '"' : "NULL";
+            $framelessFuncInfosName = !empty($this->framelessFunctionInfos) ? $this->getFramelessFunctionInfosName() : "NULL";
 
-                return sprintf(
-                    "\t%s(%s, %s, %s)\n",
-                    $macro, $functionName, $declarationName, $this->getArgInfoName()
-                );
+            $template = "\tZEND_RAW_FENTRY($zendName, $name, $argInfoName, %s, $framelessFuncInfosName, $docComment)\n";
+            $flagsCode = generateVersionDependentFlagCode(
+                $template,
+                $php84AndAboveFlags,
+                PHP_84_VERSION_ID
+            );
+            $code .= implode("", $flagsCode);
+
+            if (!$php84MinimumCompatibility) {
+                $code .= "#else\n";
             }
 
-            switch (true) {
-                case $this->isDeprecated:
-                    $macro = 'ZEND_DEP_FE';
-                    break;
-                case $this->supportsCompileTimeEval:
-                    $macro = 'ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE';
-                    break;
-                default:
-                    $macro = 'ZEND_FE';
+            if (!$php84MinimumCompatibility) {
+                $flags = array_slice($flagsByPhpVersions, 0, 4, true);
+                $template = "\tZEND_RAW_FENTRY($zendName, $name, $argInfoName, %s)\n";
+                $flagsCode = generateVersionDependentFlagCode(
+                    $template,
+                    $flags,
+                    $this->minimumPhpVersionIdCompatibility
+                );
+                $code .= implode("", $flagsCode);
             }
 
-            return sprintf("\t%s(%s, %s)\n", $macro, $functionName, $this->getArgInfoName());
-        } else {
-            throw new Error("Cannot happen");
+            if (!$php84MinimumCompatibility) {
+                $code .= "#endif\n";
+            }
         }
+
+        return $code;
     }
 
     public function getOptimizerInfo(): ?string {
@@ -1501,32 +1542,57 @@ public function discardInfoForOldPhpVersions(): void {
         }
     }
 
-    private function getFlagsAsArginfoString(): string
+    /** @return array<int, string[]> */
+    private function getArginfoFlagsByPhpVersions(): array
     {
-        $flags = "ZEND_ACC_PUBLIC";
-        if ($this->flags & Modifiers::PROTECTED) {
-            $flags = "ZEND_ACC_PROTECTED";
-        } elseif ($this->flags & Modifiers::PRIVATE) {
-            $flags = "ZEND_ACC_PRIVATE";
-        }
+        $flags = [];
 
-        if ($this->flags & Modifiers::STATIC) {
-            $flags .= "|ZEND_ACC_STATIC";
+        if ($this->isMethod()) {
+            if ($this->flags & Modifiers::PROTECTED) {
+                $flags[] = "ZEND_ACC_PROTECTED";
+            } elseif ($this->flags & Modifiers::PRIVATE) {
+                $flags[] = "ZEND_ACC_PRIVATE";
+            } else {
+                $flags[] = "ZEND_ACC_PUBLIC";
+            }
+
+            if ($this->flags & Modifiers::STATIC) {
+                $flags[] = "ZEND_ACC_STATIC";
+            }
+
+            if ($this->flags & Modifiers::FINAL) {
+                $flags[] = "ZEND_ACC_FINAL";
+            }
+
+            if ($this->flags & Modifiers::ABSTRACT) {
+                $flags[] = "ZEND_ACC_ABSTRACT";
+            }
         }
 
-        if ($this->flags & Modifiers::FINAL) {
-            $flags .= "|ZEND_ACC_FINAL";
+        if ($this->isDeprecated) {
+            $flags[] = "ZEND_ACC_DEPRECATED";
         }
 
-        if ($this->flags & Modifiers::ABSTRACT) {
-            $flags .= "|ZEND_ACC_ABSTRACT";
+        $php82AndAboveFlags = $flags;
+        if ($this->isMethod() === false && $this->supportsCompileTimeEval) {
+            $php82AndAboveFlags[] = "ZEND_ACC_COMPILE_TIME_EVAL";
         }
 
-        if ($this->isDeprecated) {
-            $flags .= "|ZEND_ACC_DEPRECATED";
+        if (empty($flags)) {
+            $flags[] = "0";
+        }
+        if (empty($php82AndAboveFlags)) {
+            $php82AndAboveFlags[] = "0";
         }
 
-        return $flags;
+        return [
+            PHP_70_VERSION_ID => $flags,
+            PHP_80_VERSION_ID => $flags,
+            PHP_81_VERSION_ID => $flags,
+            PHP_82_VERSION_ID => $php82AndAboveFlags,
+            PHP_83_VERSION_ID => $php82AndAboveFlags,
+            PHP_84_VERSION_ID => $php82AndAboveFlags,
+        ];
     }
 
     private function generateRefSect1(DOMDocument $doc, string $role): DOMElement {
@@ -2255,6 +2321,7 @@ abstract class VariableLike
     public ?int $phpVersionIdMinimumCompatibility;
     /** @var AttributeInfo[] */
     public array $attributes;
+    public ?ExposedDocComment $exposedDocComment;
 
     /**
      * @var AttributeInfo[] $attributes
@@ -2265,7 +2332,8 @@ public function __construct(
         ?Type $phpDocType,
         ?string $link,
         ?int $phpVersionIdMinimumCompatibility,
-        array $attributes
+        array $attributes,
+        ?ExposedDocComment $exposedDocComment
     ) {
         $this->flags = $flags;
         $this->type = $type;
@@ -2273,6 +2341,7 @@ public function __construct(
         $this->link = $link;
         $this->phpVersionIdMinimumCompatibility = $phpVersionIdMinimumCompatibility;
         $this->attributes = $attributes;
+        $this->exposedDocComment = $exposedDocComment;
     }
 
     abstract protected function getVariableTypeCode(): string;
@@ -2316,6 +2385,7 @@ protected function getFlagsByPhpVersion(): array
             PHP_81_VERSION_ID => [$flags],
             PHP_82_VERSION_ID => [$flags],
             PHP_83_VERSION_ID => [$flags],
+            PHP_84_VERSION_ID => [$flags],
         ];
     }
 
@@ -2458,7 +2528,8 @@ public function __construct(
         bool $isUndocumentable,
         ?string $link,
         ?int $phpVersionIdMinimumCompatibility,
-        array $attributes
+        array $attributes,
+        ?ExposedDocComment $exposedDocComment
     ) {
         $this->name = $name;
         $this->value = $value;
@@ -2467,7 +2538,7 @@ public function __construct(
         $this->cond = $cond;
         $this->cValue = $cValue;
         $this->isUndocumentable = $isUndocumentable;
-        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes);
+        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes, $exposedDocComment);
     }
 
     /** @param array<string, ConstInfo> $allConstInfos */
@@ -2651,6 +2722,15 @@ private function getClassConstDeclaration(EvaluatedValue $value, array $allConst
         $code .= "\tzend_string *const_{$constName}_name = zend_string_init_interned(\"$constName\", sizeof(\"$constName\") - 1, 1);\n";
         $nameCode = "const_{$constName}_name";
 
+        if ($this->exposedDocComment) {
+            $commentCode = "const_{$constName}_comment";
+            $escapedComment = $this->exposedDocComment->escape();
+            $escapedCommentLength = $this->exposedDocComment->getLength();
+            $code .= "\tzend_string *$commentCode = zend_string_init_interned(\"$escapedComment\", $escapedCommentLength, 1);\n";
+        } else {
+            $commentCode = "NULL";
+        }
+
         $php83MinimumCompatibility = $this->phpVersionIdMinimumCompatibility === null || $this->phpVersionIdMinimumCompatibility >= PHP_83_VERSION_ID;
 
         if ($this->type && !$php83MinimumCompatibility) {
@@ -2665,7 +2745,7 @@ private function getClassConstDeclaration(EvaluatedValue $value, array $allConst
             } else {
                 $template = "\t";
             }
-            $template .= "zend_declare_typed_class_constant(class_entry, $nameCode, &const_{$constName}_value, %s, NULL, $typeCode);\n";
+            $template .= "zend_declare_typed_class_constant(class_entry, $nameCode, &const_{$constName}_value, %s, $commentCode, $typeCode);\n";
 
             $flagsCode = generateVersionDependentFlagCode(
                 $template,
@@ -2685,7 +2765,7 @@ private function getClassConstDeclaration(EvaluatedValue $value, array $allConst
             } else {
                 $template = "\t";
             }
-            $template .= "zend_declare_class_constant_ex(class_entry, $nameCode, &const_{$constName}_value, %s, NULL);\n";
+            $template .= "zend_declare_class_constant_ex(class_entry, $nameCode, &const_{$constName}_value, %s, $commentCode);\n";
             $flagsCode = generateVersionDependentFlagCode(
                 $template,
                 $this->getFlagsByPhpVersion(),
@@ -2791,13 +2871,14 @@ public function __construct(
         bool $isDocReadonly,
         ?string $link,
         ?int $phpVersionIdMinimumCompatibility,
-        array $attributes
+        array $attributes,
+        ?ExposedDocComment $exposedDocComment
     ) {
         $this->name = $name;
         $this->defaultValue = $defaultValue;
         $this->defaultValueString = $defaultValueString;
         $this->isDocReadonly = $isDocReadonly;
-        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes);
+        parent::__construct($flags, $type, $phpDocType, $link, $phpVersionIdMinimumCompatibility, $attributes, $exposedDocComment);
     }
 
     protected function getVariableTypeCode(): string
@@ -2861,12 +2942,21 @@ public function getDeclaration(array $allConstInfos): string {
         $nameCode = "property_{$propertyName}_name";
         $typeCode = $this->getTypeCode($propertyName, $code);
 
+        if ($this->exposedDocComment) {
+            $commentCode = "property_{$propertyName}_comment";
+            $escapedComment = $this->exposedDocComment->escape();
+            $escapedCommentLength = $this->exposedDocComment->getLength();
+            $code .= "\tzend_string *$commentCode = zend_string_init_interned(\"$escapedComment\", $escapedCommentLength, 1);\n";
+        } else {
+            $commentCode = "NULL";
+        }
+
         if (!empty($this->attributes)) {
             $template = "\tzend_property_info *property_" . $this->name->getDeclarationName() . " = ";
         } else {
             $template = "\t";
         }
-        $template .= "zend_declare_typed_property(class_entry, $nameCode, &$zvalName, %s, NULL, $typeCode);\n";
+        $template .= "zend_declare_typed_property(class_entry, $nameCode, &$zvalName, %s, $commentCode, $typeCode);\n";
         $flagsCode = generateVersionDependentFlagCode(
             $template,
             $this->getFlagsByPhpVersion(),
@@ -2998,6 +3088,7 @@ class ClassInfo {
     public bool $isStrictProperties;
     /** @var AttributeInfo[] */
     public array $attributes;
+    public ?ExposedDocComment $exposedDocComment;
     public bool $isNotSerializable;
     /** @var Name[] */
     public array $extends;
@@ -3033,6 +3124,7 @@ public function __construct(
         bool $isDeprecated,
         bool $isStrictProperties,
         array $attributes,
+        ?ExposedDocComment $exposedDocComment,
         bool $isNotSerializable,
         array $extends,
         array $implements,
@@ -3052,6 +3144,7 @@ public function __construct(
         $this->isDeprecated = $isDeprecated;
         $this->isStrictProperties = $isStrictProperties;
         $this->attributes = $attributes;
+        $this->exposedDocComment = $exposedDocComment;
         $this->isNotSerializable = $isNotSerializable;
         $this->extends = $extends;
         $this->implements = $implements;
@@ -3081,6 +3174,7 @@ public function getRegistration(array $allConstInfos): string
 
         $php80MinimumCompatibility = $this->phpVersionIdMinimumCompatibility === null || $this->phpVersionIdMinimumCompatibility >= PHP_80_VERSION_ID;
         $php81MinimumCompatibility = $this->phpVersionIdMinimumCompatibility === null || $this->phpVersionIdMinimumCompatibility >= PHP_81_VERSION_ID;
+        $php84MinimumCompatibility = $this->phpVersionIdMinimumCompatibility === null || $this->phpVersionIdMinimumCompatibility >= PHP_84_VERSION_ID;
 
         if ($this->type === "enum" && !$php81MinimumCompatibility) {
             $code .= "#if (PHP_VERSION_ID >= " . PHP_81_VERSION_ID . ")\n";
@@ -3119,6 +3213,18 @@ public function getRegistration(array $allConstInfos): string
         $flagCodes = generateVersionDependentFlagCode("\tclass_entry->ce_flags |= %s;\n", $this->getFlagsByPhpVersion(), $this->phpVersionIdMinimumCompatibility);
         $code .= implode("", $flagCodes);
 
+        if ($this->exposedDocComment) {
+            if (!$php84MinimumCompatibility) {
+                $code .= "#if (PHP_VERSION_ID >= " . PHP_84_VERSION_ID . ")\n";
+            }
+
+            $code .= "\tclass_entry->doc_comment = zend_string_init_interned(\"" . $this->exposedDocComment->escape() . "\", " . $this->exposedDocComment->getLength() . ", 1);\n";
+
+            if (!$php84MinimumCompatibility) {
+                $code .= "#endif\n";
+            }
+        }
+
         $implements = array_map(
             function (Name $item) {
                 return "class_entry_" . implode("_", $item->getParts());
@@ -3265,6 +3371,7 @@ private function getFlagsByPhpVersion(): array
         }
 
         $php83Flags = $php82Flags;
+        $php84Flags = $php83Flags;
 
         return [
             PHP_70_VERSION_ID => $php70Flags,
@@ -3272,6 +3379,7 @@ private function getFlagsByPhpVersion(): array
             PHP_81_VERSION_ID => $php81Flags,
             PHP_82_VERSION_ID => $php82Flags,
             PHP_83_VERSION_ID => $php83Flags,
+            PHP_84_VERSION_ID => $php84Flags,
         ];
     }
 
@@ -3850,6 +3958,34 @@ public function getVariableName(): string {
     }
 }
 
+class ExposedDocComment {
+    private string $docComment;
+
+    public function __construct(string $docComment) {
+        $this->docComment = $docComment;
+    }
+
+    public function escape(): string {
+        return str_replace("\n", '\n', addslashes($this->docComment));
+    }
+
+    public function getLength(): int {
+        return strlen($this->docComment);
+    }
+}
+
+/** @return DocCommentTag[] */
+function parseDocComments(array $comments): array {
+    $tags = [];
+    foreach ($comments as $comment) {
+        if ($comment instanceof DocComment) {
+            $tags = array_merge($tags, parseDocComment($comment));
+        }
+    }
+
+    return $tags;
+}
+
 /** @return DocCommentTag[] */
 function parseDocComment(DocComment $comment): array {
     $commentText = substr($comment->getText(), 2, -2);
@@ -3883,10 +4019,11 @@ function parseFunctionLike(
     int $flags,
     Node\FunctionLike $func,
     ?string $cond,
-    bool $isUndocumentable
+    bool $isUndocumentable,
+    ?int $minimumPhpVersionIdCompatibility
 ): FuncInfo {
     try {
-        $comment = $func->getDocComment();
+        $comments = $func->getComments();
         $paramMeta = [];
         $aliasType = null;
         $alias = null;
@@ -3899,8 +4036,9 @@ function parseFunctionLike(
         $refcount = null;
         $framelessFunctionInfos = [];
 
-        if ($comment) {
-            $tags = parseDocComment($comment);
+        if ($comments) {
+            $tags = parseDocComments($comments);
+
             foreach ($tags as $tag) {
                 switch ($tag->name) {
                     case 'alias':
@@ -4057,8 +4195,10 @@ function parseFunctionLike(
             $numRequiredArgs,
             $cond,
             $isUndocumentable,
+            $minimumPhpVersionIdCompatibility,
             createAttributes($func->attrGroups),
-            $framelessFunctionInfos
+            $framelessFunctionInfos,
+            createExposedDocComment($comments)
         );
     } catch (Exception $e) {
         throw new Exception($name . "(): " .$e->getMessage());
@@ -4074,7 +4214,7 @@ function parseConstLike(
     Node\Const_ $const,
     int $flags,
     ?Node $type,
-    ?DocComment $docComment,
+    array $comments,
     ?string $cond,
     bool $isUndocumentable,
     ?int $phpVersionIdMinimumCompatibility,
@@ -4084,8 +4224,8 @@ function parseConstLike(
     $deprecated = false;
     $cValue = null;
     $link = null;
-    if ($docComment) {
-        $tags = parseDocComment($docComment);
+    if ($comments) {
+        $tags = parseDocComments($comments);
         foreach ($tags as $tag) {
             if ($tag->name === 'var') {
                 $phpDocType = $tag->getType();
@@ -4118,7 +4258,8 @@ function parseConstLike(
         $isUndocumentable,
         $link,
         $phpVersionIdMinimumCompatibility,
-        $attributes
+        $attributes,
+        createExposedDocComment($comments)
     );
 }
 
@@ -4130,7 +4271,7 @@ function parseProperty(
     int $flags,
     Stmt\PropertyProperty $property,
     ?Node $type,
-    ?DocComment $comment,
+    array $comments,
     PrettyPrinterAbstract $prettyPrinter,
     ?int $phpVersionIdMinimumCompatibility,
     array $attributes
@@ -4139,8 +4280,8 @@ function parseProperty(
     $isDocReadonly = false;
     $link = null;
 
-    if ($comment) {
-        $tags = parseDocComment($comment);
+    if ($comments) {
+        $tags = parseDocComments($comments);
         foreach ($tags as $tag) {
             if ($tag->name === 'var') {
                 $phpDocType = $tag->getType();
@@ -4178,7 +4319,8 @@ function parseProperty(
         $isDocReadonly,
         $link,
         $phpVersionIdMinimumCompatibility,
-        $attributes
+        $attributes,
+        createExposedDocComment($comments)
     );
 }
 
@@ -4200,7 +4342,7 @@ function parseClass(
     bool $isUndocumentable
 ): ClassInfo {
     $flags = $class instanceof Class_ ? $class->flags : 0;
-    $comment = $class->getDocComment();
+    $comments = $class->getComments();
     $alias = null;
     $isDeprecated = false;
     $isStrictProperties = false;
@@ -4208,8 +4350,8 @@ function parseClass(
     $allowsDynamicProperties = false;
     $attributes = [];
 
-    if ($comment) {
-        $tags = parseDocComment($comment);
+    if ($comments) {
+        $tags = parseDocComments($comments);
         foreach ($tags as $tag) {
             if ($tag->name === 'alias') {
                 $alias = $tag->getValue();
@@ -4275,6 +4417,7 @@ function parseClass(
         $isDeprecated,
         $isStrictProperties,
         $attributes,
+        createExposedDocComment($comments),
         $isNotSerializable,
         $extends,
         $implements,
@@ -4304,6 +4447,29 @@ function createAttributes(array $attributeGroups): array {
     return $attributes;
 }
 
+/** @param array<int, DocComment> $comments */
+function createExposedDocComment(array $comments): ?ExposedDocComment {
+    $exposedDocComment = null;
+
+    foreach ($comments as $comment) {
+        $text = $comment->getText();
+        $matches = [];
+        $pattern = "#^(\s*\/\*\*)(\s*@genstubs-expose-comment-block)(\s*)$#m";
+
+        if (preg_match($pattern, $text, $matches) !== 1) {
+            continue;
+        }
+
+        if ($exposedDocComment !== null) {
+            throw new Exception("Only one PHPDoc comment block can be exposed");
+        }
+
+        $exposedDocComment = preg_replace($pattern, '$1$3', $text);
+    }
+
+    return $exposedDocComment ? new ExposedDocComment($exposedDocComment) : null;
+}
+
 function handlePreprocessorConditions(array &$conds, Stmt $stmt): ?string {
     foreach ($stmt->getComments() as $comment) {
         $text = trim($comment->getText());
@@ -4371,7 +4537,7 @@ function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstrac
                     $const,
                     0,
                     null,
-                    $stmt->getDocComment(),
+                    $stmt->getComments(),
                     $cond,
                     $fileInfo->isUndocumentable,
                     $fileInfo->generateLegacyArginfoForPhpVersionId,
@@ -4389,7 +4555,8 @@ function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstrac
                 0,
                 $stmt,
                 $cond,
-                $fileInfo->isUndocumentable
+                $fileInfo->isUndocumentable,
+                $fileInfo->generateLegacyArginfoForPhpVersionId
             );
             continue;
         }
@@ -4417,7 +4584,7 @@ function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstrac
                             $const,
                             $classStmt->flags,
                             $classStmt->type,
-                            $classStmt->getDocComment(),
+                            $classStmt->getComments(),
                             $cond,
                             $fileInfo->isUndocumentable,
                             $fileInfo->generateLegacyArginfoForPhpVersionId,
@@ -4434,7 +4601,7 @@ function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstrac
                             $classStmt->flags,
                             $property,
                             $classStmt->type,
-                            $classStmt->getDocComment(),
+                            $classStmt->getComments(),
                             $prettyPrinter,
                             $fileInfo->generateLegacyArginfoForPhpVersionId,
                             createAttributes($classStmt->attrGroups)
@@ -4451,7 +4618,8 @@ function handleStatements(FileInfo $fileInfo, array $stmts, PrettyPrinterAbstrac
                         $classStmt->flags | $abstractFlag,
                         $classStmt,
                         $cond,
-                        $fileInfo->isUndocumentable
+                        $fileInfo->isUndocumentable,
+                        $fileInfo->generateLegacyArginfoForPhpVersionId
                     );
                 } else if ($classStmt instanceof Stmt\EnumCase) {
                     $enumCaseInfos[] = new EnumCaseInfo(
@@ -4772,7 +4940,7 @@ static function (FuncInfo $funcInfo) use ($fileInfo, &$generatedFunctionDeclarat
                 $code .= $constInfo->getDeclaration($allConstInfos);
             }
 
-            if (!empty($attributeInitializationCode !== "" && $fileInfo->constInfos)) {
+            if ($attributeInitializationCode !== "" && $fileInfo->constInfos) {
                 $code .= "\n";
             }
 
diff --git a/ext/bz2/bz2_arginfo.h b/ext/bz2/bz2_arginfo.h
index 85a8def5a8a9f..e7bde62684eb3 100644
--- a/ext/bz2/bz2_arginfo.h
+++ b/ext/bz2/bz2_arginfo.h
@@ -60,9 +60,9 @@ ZEND_FUNCTION(bzdecompress);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(bzopen, arginfo_bzopen)
 	ZEND_FE(bzread, arginfo_bzread)
-	ZEND_FALIAS(bzwrite, fwrite, arginfo_bzwrite)
-	ZEND_FALIAS(bzflush, fflush, arginfo_bzflush)
-	ZEND_FALIAS(bzclose, fclose, arginfo_bzclose)
+	ZEND_RAW_FENTRY("bzwrite", zif_fwrite, arginfo_bzwrite, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("bzflush", zif_fflush, arginfo_bzflush, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("bzclose", zif_fclose, arginfo_bzclose, 0, NULL, NULL)
 	ZEND_FE(bzerrno, arginfo_bzerrno)
 	ZEND_FE(bzerrstr, arginfo_bzerrstr)
 	ZEND_FE(bzerror, arginfo_bzerror)
diff --git a/ext/com_dotnet/com_handlers.c b/ext/com_dotnet/com_handlers.c
index 0c73d8c4a3a72..1965153f027f5 100644
--- a/ext/com_dotnet/com_handlers.c
+++ b/ext/com_dotnet/com_handlers.c
@@ -311,6 +311,7 @@ static zend_function *com_method_get(zend_object **object_ptr, zend_string *name
 		f.fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
 		f.function_name = zend_string_copy(name);
 		f.handler = PHP_FN(com_method_handler);
+		f.doc_comment = NULL;
 
 		fptr = &f;
 
diff --git a/ext/date/php_date_arginfo.h b/ext/date/php_date_arginfo.h
index c0788289e7984..73c8b521bf288 100644
--- a/ext/date/php_date_arginfo.h
+++ b/ext/date/php_date_arginfo.h
@@ -622,8 +622,8 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(mktime, arginfo_mktime)
 	ZEND_FE(gmmktime, arginfo_gmmktime)
 	ZEND_FE(checkdate, arginfo_checkdate)
-	ZEND_DEP_FE(strftime, arginfo_strftime)
-	ZEND_DEP_FE(gmstrftime, arginfo_gmstrftime)
+	ZEND_RAW_FENTRY("strftime", zif_strftime, arginfo_strftime, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("gmstrftime", zif_gmstrftime, arginfo_gmstrftime, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(time, arginfo_time)
 	ZEND_FE(localtime, arginfo_localtime)
 	ZEND_FE(getdate, arginfo_getdate)
@@ -660,21 +660,21 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(date_interval_format, arginfo_date_interval_format)
 	ZEND_FE(date_default_timezone_set, arginfo_date_default_timezone_set)
 	ZEND_FE(date_default_timezone_get, arginfo_date_default_timezone_get)
-	ZEND_DEP_FE(date_sunrise, arginfo_date_sunrise)
-	ZEND_DEP_FE(date_sunset, arginfo_date_sunset)
+	ZEND_RAW_FENTRY("date_sunrise", zif_date_sunrise, arginfo_date_sunrise, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("date_sunset", zif_date_sunset, arginfo_date_sunset, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(date_sun_info, arginfo_date_sun_info)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_DateTimeInterface_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, format, arginfo_class_DateTimeInterface_format, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, getTimezone, arginfo_class_DateTimeInterface_getTimezone, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, getOffset, arginfo_class_DateTimeInterface_getOffset, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, getTimestamp, arginfo_class_DateTimeInterface_getTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, diff, arginfo_class_DateTimeInterface_diff, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, __wakeup, arginfo_class_DateTimeInterface___wakeup, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, __serialize, arginfo_class_DateTimeInterface___serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DateTimeInterface, __unserialize, arginfo_class_DateTimeInterface___unserialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("format", NULL, arginfo_class_DateTimeInterface_format, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimezone", NULL, arginfo_class_DateTimeInterface_getTimezone, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getOffset", NULL, arginfo_class_DateTimeInterface_getOffset, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimestamp", NULL, arginfo_class_DateTimeInterface_getTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("diff", NULL, arginfo_class_DateTimeInterface_diff, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("__wakeup", NULL, arginfo_class_DateTimeInterface___wakeup, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("__serialize", NULL, arginfo_class_DateTimeInterface___serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("__unserialize", NULL, arginfo_class_DateTimeInterface___unserialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -686,24 +686,24 @@ static const zend_function_entry class_DateTime_methods[] = {
 	ZEND_ME(DateTime, __set_state, arginfo_class_DateTime___set_state, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DateTime, createFromImmutable, arginfo_class_DateTime_createFromImmutable, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DateTime, createFromInterface, arginfo_class_DateTime_createFromInterface, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createFromFormat, date_create_from_format, arginfo_class_DateTime_createFromFormat, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("createFromFormat", zif_date_create_from_format, arginfo_class_DateTime_createFromFormat, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 	ZEND_ME(DateTime, createFromTimestamp, arginfo_class_DateTime_createFromTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getLastErrors, date_get_last_errors, arginfo_class_DateTime_getLastErrors, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(format, date_format, arginfo_class_DateTime_format, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getLastErrors", zif_date_get_last_errors, arginfo_class_DateTime_getLastErrors, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("format", zif_date_format, arginfo_class_DateTime_format, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateTime, modify, arginfo_class_DateTime_modify, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(add, date_add, arginfo_class_DateTime_add, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("add", zif_date_add, arginfo_class_DateTime_add, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateTime, sub, arginfo_class_DateTime_sub, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimezone, date_timezone_get, arginfo_class_DateTime_getTimezone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTimezone, date_timezone_set, arginfo_class_DateTime_setTimezone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getOffset, date_offset_get, arginfo_class_DateTime_getOffset, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getTimezone", zif_date_timezone_get, arginfo_class_DateTime_getTimezone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTimezone", zif_date_timezone_set, arginfo_class_DateTime_setTimezone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getOffset", zif_date_offset_get, arginfo_class_DateTime_getOffset, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateTime, getMicroseconds, arginfo_class_DateTime_getMicroseconds, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTime, date_time_set, arginfo_class_DateTime_setTime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setDate, date_date_set, arginfo_class_DateTime_setDate, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setISODate, date_isodate_set, arginfo_class_DateTime_setISODate, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTimestamp, date_timestamp_set, arginfo_class_DateTime_setTimestamp, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("setTime", zif_date_time_set, arginfo_class_DateTime_setTime, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setDate", zif_date_date_set, arginfo_class_DateTime_setDate, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setISODate", zif_date_isodate_set, arginfo_class_DateTime_setISODate, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTimestamp", zif_date_timestamp_set, arginfo_class_DateTime_setTimestamp, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateTime, setMicroseconds, arginfo_class_DateTime_setMicroseconds, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimestamp, date_timestamp_get, arginfo_class_DateTime_getTimestamp, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(diff, date_diff, arginfo_class_DateTime_diff, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getTimestamp", zif_date_timestamp_get, arginfo_class_DateTime_getTimestamp, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("diff", zif_date_diff, arginfo_class_DateTime_diff, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -713,15 +713,15 @@ static const zend_function_entry class_DateTimeImmutable_methods[] = {
 	ZEND_ME(DateTimeImmutable, __unserialize, arginfo_class_DateTimeImmutable___unserialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeImmutable, __wakeup, arginfo_class_DateTimeImmutable___wakeup, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeImmutable, __set_state, arginfo_class_DateTimeImmutable___set_state, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createFromFormat, date_create_immutable_from_format, arginfo_class_DateTimeImmutable_createFromFormat, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("createFromFormat", zif_date_create_immutable_from_format, arginfo_class_DateTimeImmutable_createFromFormat, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 	ZEND_ME(DateTimeImmutable, createFromTimestamp, arginfo_class_DateTimeImmutable_createFromTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getLastErrors, date_get_last_errors, arginfo_class_DateTimeImmutable_getLastErrors, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(format, date_format, arginfo_class_DateTimeImmutable_format, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimezone, date_timezone_get, arginfo_class_DateTimeImmutable_getTimezone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getOffset, date_offset_get, arginfo_class_DateTimeImmutable_getOffset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimestamp, date_timestamp_get, arginfo_class_DateTimeImmutable_getTimestamp, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DateTime, getMicroseconds, getMicroseconds, arginfo_class_DateTimeImmutable_getMicroseconds, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(diff, date_diff, arginfo_class_DateTimeImmutable_diff, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getLastErrors", zif_date_get_last_errors, arginfo_class_DateTimeImmutable_getLastErrors, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("format", zif_date_format, arginfo_class_DateTimeImmutable_format, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimezone", zif_date_timezone_get, arginfo_class_DateTimeImmutable_getTimezone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getOffset", zif_date_offset_get, arginfo_class_DateTimeImmutable_getOffset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimestamp", zif_date_timestamp_get, arginfo_class_DateTimeImmutable_getTimestamp, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMicroseconds", zim_DateTime_getMicroseconds, arginfo_class_DateTimeImmutable_getMicroseconds, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("diff", zif_date_diff, arginfo_class_DateTimeImmutable_diff, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateTimeImmutable, modify, arginfo_class_DateTimeImmutable_modify, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeImmutable, add, arginfo_class_DateTimeImmutable_add, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeImmutable, sub, arginfo_class_DateTimeImmutable_sub, ZEND_ACC_PUBLIC)
@@ -738,12 +738,12 @@ static const zend_function_entry class_DateTimeImmutable_methods[] = {
 
 static const zend_function_entry class_DateTimeZone_methods[] = {
 	ZEND_ME(DateTimeZone, __construct, arginfo_class_DateTimeZone___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getName, timezone_name_get, arginfo_class_DateTimeZone_getName, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getOffset, timezone_offset_get, arginfo_class_DateTimeZone_getOffset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTransitions, timezone_transitions_get, arginfo_class_DateTimeZone_getTransitions, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocation, timezone_location_get, arginfo_class_DateTimeZone_getLocation, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(listAbbreviations, timezone_abbreviations_list, arginfo_class_DateTimeZone_listAbbreviations, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(listIdentifiers, timezone_identifiers_list, arginfo_class_DateTimeZone_listIdentifiers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getName", zif_timezone_name_get, arginfo_class_DateTimeZone_getName, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getOffset", zif_timezone_offset_get, arginfo_class_DateTimeZone_getOffset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTransitions", zif_timezone_transitions_get, arginfo_class_DateTimeZone_getTransitions, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocation", zif_timezone_location_get, arginfo_class_DateTimeZone_getLocation, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("listAbbreviations", zif_timezone_abbreviations_list, arginfo_class_DateTimeZone_listAbbreviations, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("listIdentifiers", zif_timezone_identifiers_list, arginfo_class_DateTimeZone_listIdentifiers, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 	ZEND_ME(DateTimeZone, __serialize, arginfo_class_DateTimeZone___serialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeZone, __unserialize, arginfo_class_DateTimeZone___unserialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateTimeZone, __wakeup, arginfo_class_DateTimeZone___wakeup, ZEND_ACC_PUBLIC)
@@ -754,7 +754,7 @@ static const zend_function_entry class_DateTimeZone_methods[] = {
 static const zend_function_entry class_DateInterval_methods[] = {
 	ZEND_ME(DateInterval, __construct, arginfo_class_DateInterval___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateInterval, createFromDateString, arginfo_class_DateInterval_createFromDateString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(format, date_interval_format, arginfo_class_DateInterval_format, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("format", zif_date_interval_format, arginfo_class_DateInterval_format, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DateInterval, __serialize, arginfo_class_DateInterval___serialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateInterval, __unserialize, arginfo_class_DateInterval___unserialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(DateInterval, __wakeup, arginfo_class_DateInterval___wakeup, ZEND_ACC_PUBLIC)
diff --git a/ext/dl_test/dl_test.c b/ext/dl_test/dl_test.c
index 5a5dfee33f5b0..33008a2b57205 100644
--- a/ext/dl_test/dl_test.c
+++ b/ext/dl_test/dl_test.c
@@ -64,7 +64,7 @@ PHP_FUNCTION(dl_test_use_register_functions_directly)
 }
 
 static const zend_function_entry php_dl_test_use_register_functions_directly_functions[] = {
-	ZEND_FENTRY(dl_test_use_register_functions_directly, ZEND_FN(dl_test_use_register_functions_directly), arginfo_dl_test_use_register_functions_directly,  0)
+	ZEND_FENTRY(dl_test_use_register_functions_directly, ZEND_FN(dl_test_use_register_functions_directly), arginfo_dl_test_use_register_functions_directly, 0)
 	ZEND_FE_END
 };
 /* }}} */
diff --git a/ext/dom/php_dom_arginfo.h b/ext/dom/php_dom_arginfo.h
index 95cc8e245478e..0c86ac8d73f5b 100644
--- a/ext/dom/php_dom_arginfo.h
+++ b/ext/dom/php_dom_arginfo.h
@@ -797,7 +797,7 @@ ZEND_METHOD(DOM_XMLDocument, createFromString);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(dom_import_simplexml, arginfo_dom_import_simplexml)
-	ZEND_NS_FALIAS("DOM", import_simplexml, dom_import_simplexml, arginfo_DOM_import_simplexml)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("DOM", "import_simplexml"), zif_dom_import_simplexml, arginfo_DOM_import_simplexml, 0, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -816,17 +816,17 @@ static const zend_function_entry class_DOMComment_methods[] = {
 };
 
 static const zend_function_entry class_DOMParentNode_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMParentNode, append, arginfo_class_DOMParentNode_append, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMParentNode, prepend, arginfo_class_DOMParentNode_prepend, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMParentNode, replaceChildren, arginfo_class_DOMParentNode_replaceChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("append", NULL, arginfo_class_DOMParentNode_append, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("prepend", NULL, arginfo_class_DOMParentNode_prepend, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("replaceChildren", NULL, arginfo_class_DOMParentNode_replaceChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_DOMChildNode_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMChildNode, remove, arginfo_class_DOMChildNode_remove, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMChildNode, before, arginfo_class_DOMChildNode_before, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMChildNode, after, arginfo_class_DOMChildNode_after, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(DOMChildNode, replaceWith, arginfo_class_DOMChildNode_replaceWith, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("remove", NULL, arginfo_class_DOMChildNode_remove, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("before", NULL, arginfo_class_DOMChildNode_before, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("after", NULL, arginfo_class_DOMChildNode_after, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("replaceWith", NULL, arginfo_class_DOMChildNode_replaceWith, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -858,8 +858,8 @@ static const zend_function_entry class_DOMNode_methods[] = {
 };
 
 static const zend_function_entry class_DOMNameSpaceNode_methods[] = {
-	ZEND_MALIAS(DOMNode, __sleep, __sleep, arginfo_class_DOMNameSpaceNode___sleep, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMNode, __wakeup, __wakeup, arginfo_class_DOMNameSpaceNode___wakeup, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__sleep", zim_DOMNode___sleep, arginfo_class_DOMNameSpaceNode___sleep, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__wakeup", zim_DOMNode___wakeup, arginfo_class_DOMNameSpaceNode___wakeup, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -874,9 +874,9 @@ static const zend_function_entry class_DOMImplementation_methods[] = {
 static const zend_function_entry class_DOMDocumentFragment_methods[] = {
 	ZEND_ME(DOMDocumentFragment, __construct, arginfo_class_DOMDocumentFragment___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(DOMDocumentFragment, appendXML, arginfo_class_DOMDocumentFragment_appendXML, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, append, append, arginfo_class_DOMDocumentFragment_append, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, prepend, prepend, arginfo_class_DOMDocumentFragment_prepend, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOM_Document, replaceChildren, replaceChildren, arginfo_class_DOMDocumentFragment_replaceChildren, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("append", zim_DOMElement_append, arginfo_class_DOMDocumentFragment_append, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("prepend", zim_DOMElement_prepend, arginfo_class_DOMDocumentFragment_prepend, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("replaceChildren", zim_DOM_Document_replaceChildren, arginfo_class_DOMDocumentFragment_replaceChildren, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -893,10 +893,10 @@ static const zend_function_entry class_DOMCharacterData_methods[] = {
 	ZEND_ME(DOMCharacterData, insertData, arginfo_class_DOMCharacterData_insertData, ZEND_ACC_PUBLIC)
 	ZEND_ME(DOMCharacterData, deleteData, arginfo_class_DOMCharacterData_deleteData, ZEND_ACC_PUBLIC)
 	ZEND_ME(DOMCharacterData, replaceData, arginfo_class_DOMCharacterData_replaceData, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, replaceWith, replaceWith, arginfo_class_DOMCharacterData_replaceWith, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, remove, remove, arginfo_class_DOMCharacterData_remove, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, before, before, arginfo_class_DOMCharacterData_before, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, after, after, arginfo_class_DOMCharacterData_after, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("replaceWith", zim_DOMElement_replaceWith, arginfo_class_DOMCharacterData_replaceWith, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("remove", zim_DOMElement_remove, arginfo_class_DOMCharacterData_remove, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("before", zim_DOMElement_before, arginfo_class_DOMCharacterData_before, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("after", zim_DOMElement_after, arginfo_class_DOMCharacterData_after, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -971,7 +971,7 @@ static const zend_function_entry class_DOMException_methods[] = {
 static const zend_function_entry class_DOMText_methods[] = {
 	ZEND_ME(DOMText, __construct, arginfo_class_DOMText___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(DOMText, isWhitespaceInElementContent, arginfo_class_DOMText_isWhitespaceInElementContent, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMText, isElementContentWhitespace, isWhitespaceInElementContent, arginfo_class_DOMText_isElementContentWhitespace, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("isElementContentWhitespace", zim_DOMText_isWhitespaceInElementContent, arginfo_class_DOMText_isElementContentWhitespace, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DOMText, splitText, arginfo_class_DOMText_splitText, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
@@ -1045,8 +1045,8 @@ static const zend_function_entry class_DOM_Document_methods[] = {
 	ZEND_ME(DOM_Document, relaxNGValidateSource, arginfo_class_DOM_Document_relaxNGValidateSource, ZEND_ACC_PUBLIC)
 #endif
 	ZEND_ME(DOM_Document, adoptNode, arginfo_class_DOM_Document_adoptNode, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, append, append, arginfo_class_DOM_Document_append, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMElement, prepend, prepend, arginfo_class_DOM_Document_prepend, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("append", zim_DOMElement_append, arginfo_class_DOM_Document_append, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("prepend", zim_DOMElement_prepend, arginfo_class_DOM_Document_prepend, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DOM_Document, replaceChildren, arginfo_class_DOM_Document_replaceChildren, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
@@ -1056,23 +1056,23 @@ static const zend_function_entry class_DOM_HTMLDocument_methods[] = {
 	ZEND_ME(DOM_HTMLDocument, createEmpty, arginfo_class_DOM_HTMLDocument_createEmpty, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DOM_HTMLDocument, createFromFile, arginfo_class_DOM_HTMLDocument_createFromFile, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DOM_HTMLDocument, createFromString, arginfo_class_DOM_HTMLDocument_createFromString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_MALIAS(DOMDocument, saveXML, saveXML, arginfo_class_DOM_HTMLDocument_saveXML, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMDocument, saveXMLFile, save, arginfo_class_DOM_HTMLDocument_saveXMLFile, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("saveXML", zim_DOMDocument_saveXML, arginfo_class_DOM_HTMLDocument_saveXML, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("saveXMLFile", zim_DOMDocument_save, arginfo_class_DOM_HTMLDocument_saveXMLFile, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(DOM_HTMLDocument, saveHTML, arginfo_class_DOM_HTMLDocument_saveHTML, ZEND_ACC_PUBLIC)
 	ZEND_ME(DOM_HTMLDocument, saveHTMLFile, arginfo_class_DOM_HTMLDocument_saveHTMLFile, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_DOM_XMLDocument_methods[] = {
-	ZEND_MALIAS(DOM_HTMLDocument, __construct, __construct, arginfo_class_DOM_XMLDocument___construct, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__construct", zim_DOM_HTMLDocument___construct, arginfo_class_DOM_XMLDocument___construct, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(DOM_XMLDocument, createEmpty, arginfo_class_DOM_XMLDocument_createEmpty, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DOM_XMLDocument, createFromFile, arginfo_class_DOM_XMLDocument_createFromFile, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(DOM_XMLDocument, createFromString, arginfo_class_DOM_XMLDocument_createFromString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_MALIAS(DOMDocument, createEntityReference, createEntityReference, arginfo_class_DOM_XMLDocument_createEntityReference, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMDocument, validate, validate, arginfo_class_DOM_XMLDocument_validate, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMDocument, xinclude, xinclude, arginfo_class_DOM_XMLDocument_xinclude, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMDocument, saveXML, saveXML, arginfo_class_DOM_XMLDocument_saveXML, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DOMDocument, saveXMLFile, save, arginfo_class_DOM_XMLDocument_saveXMLFile, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("createEntityReference", zim_DOMDocument_createEntityReference, arginfo_class_DOM_XMLDocument_createEntityReference, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("validate", zim_DOMDocument_validate, arginfo_class_DOM_XMLDocument_validate, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("xinclude", zim_DOMDocument_xinclude, arginfo_class_DOM_XMLDocument_xinclude, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("saveXML", zim_DOMDocument_saveXML, arginfo_class_DOM_XMLDocument_saveXML, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("saveXMLFile", zim_DOMDocument_save, arginfo_class_DOM_XMLDocument_saveXMLFile, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/enchant/enchant_arginfo.h b/ext/enchant/enchant_arginfo.h
index d4fe800bf6f88..f67e0828881ca 100644
--- a/ext/enchant/enchant_arginfo.h
+++ b/ext/enchant/enchant_arginfo.h
@@ -121,14 +121,14 @@ ZEND_FUNCTION(enchant_dict_describe);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(enchant_broker_init, arginfo_enchant_broker_init)
-	ZEND_DEP_FE(enchant_broker_free, arginfo_enchant_broker_free)
+	ZEND_RAW_FENTRY("enchant_broker_free", zif_enchant_broker_free, arginfo_enchant_broker_free, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(enchant_broker_get_error, arginfo_enchant_broker_get_error)
-	ZEND_DEP_FE(enchant_broker_set_dict_path, arginfo_enchant_broker_set_dict_path)
-	ZEND_DEP_FE(enchant_broker_get_dict_path, arginfo_enchant_broker_get_dict_path)
+	ZEND_RAW_FENTRY("enchant_broker_set_dict_path", zif_enchant_broker_set_dict_path, arginfo_enchant_broker_set_dict_path, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("enchant_broker_get_dict_path", zif_enchant_broker_get_dict_path, arginfo_enchant_broker_get_dict_path, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(enchant_broker_list_dicts, arginfo_enchant_broker_list_dicts)
 	ZEND_FE(enchant_broker_request_dict, arginfo_enchant_broker_request_dict)
 	ZEND_FE(enchant_broker_request_pwl_dict, arginfo_enchant_broker_request_pwl_dict)
-	ZEND_DEP_FE(enchant_broker_free_dict, arginfo_enchant_broker_free_dict)
+	ZEND_RAW_FENTRY("enchant_broker_free_dict", zif_enchant_broker_free_dict, arginfo_enchant_broker_free_dict, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(enchant_broker_dict_exists, arginfo_enchant_broker_dict_exists)
 	ZEND_FE(enchant_broker_set_ordering, arginfo_enchant_broker_set_ordering)
 	ZEND_FE(enchant_broker_describe, arginfo_enchant_broker_describe)
@@ -136,10 +136,10 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(enchant_dict_check, arginfo_enchant_dict_check)
 	ZEND_FE(enchant_dict_suggest, arginfo_enchant_dict_suggest)
 	ZEND_FE(enchant_dict_add, arginfo_enchant_dict_add)
-	ZEND_DEP_FALIAS(enchant_dict_add_to_personal, enchant_dict_add, arginfo_enchant_dict_add_to_personal)
+	ZEND_RAW_FENTRY("enchant_dict_add_to_personal", zif_enchant_dict_add, arginfo_enchant_dict_add_to_personal, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(enchant_dict_add_to_session, arginfo_enchant_dict_add_to_session)
 	ZEND_FE(enchant_dict_is_added, arginfo_enchant_dict_is_added)
-	ZEND_DEP_FALIAS(enchant_dict_is_in_session, enchant_dict_is_added, arginfo_enchant_dict_is_in_session)
+	ZEND_RAW_FENTRY("enchant_dict_is_in_session", zif_enchant_dict_is_added, arginfo_enchant_dict_is_in_session, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(enchant_dict_store_replacement, arginfo_enchant_dict_store_replacement)
 	ZEND_FE(enchant_dict_get_error, arginfo_enchant_dict_get_error)
 	ZEND_FE(enchant_dict_describe, arginfo_enchant_dict_describe)
diff --git a/ext/ffi/ffi.c b/ext/ffi/ffi.c
index d98b6ef1ea889..f1ae201f79745 100644
--- a/ext/ffi/ffi.c
+++ b/ext/ffi/ffi.c
@@ -2175,6 +2175,7 @@ static zend_result zend_ffi_cdata_get_closure(zend_object *obj, zend_class_entry
 	func->common.arg_info = NULL;
 	func->internal_function.handler = ZEND_FN(ffi_trampoline);
 	func->internal_function.module = NULL;
+	func->internal_function.doc_comment = NULL;
 
 	func->internal_function.reserved[0] = type;
 	func->internal_function.reserved[1] = *(void**)cdata->ptr;
@@ -2927,6 +2928,7 @@ static zend_function *zend_ffi_get_func(zend_object **obj, zend_string *name, co
 	func->common.arg_info = NULL;
 	func->internal_function.handler = ZEND_FN(ffi_trampoline);
 	func->internal_function.module = NULL;
+	func->internal_function.doc_comment = NULL;
 
 	func->internal_function.reserved[0] = type;
 	func->internal_function.reserved[1] = sym->addr;
diff --git a/ext/fileinfo/fileinfo_arginfo.h b/ext/fileinfo/fileinfo_arginfo.h
index 51dbcf2b6f021..dd4acc91585b3 100644
--- a/ext/fileinfo/fileinfo_arginfo.h
+++ b/ext/fileinfo/fileinfo_arginfo.h
@@ -72,10 +72,10 @@ static const zend_function_entry ext_functions[] = {
 };
 
 static const zend_function_entry class_finfo_methods[] = {
-	ZEND_ME_MAPPING(__construct, finfo_open, arginfo_class_finfo___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(file, finfo_file, arginfo_class_finfo_file, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(buffer, finfo_buffer, arginfo_class_finfo_buffer, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(set_flags, finfo_set_flags, arginfo_class_finfo_set_flags, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__construct", zif_finfo_open, arginfo_class_finfo___construct, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("file", zif_finfo_file, arginfo_class_finfo_file, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("buffer", zif_finfo_buffer, arginfo_class_finfo_buffer, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("set_flags", zif_finfo_set_flags, arginfo_class_finfo_set_flags, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/ftp/ftp_arginfo.h b/ext/ftp/ftp_arginfo.h
index d553bacc61db5..9aa6fcb48b352 100644
--- a/ext/ftp/ftp_arginfo.h
+++ b/ext/ftp/ftp_arginfo.h
@@ -267,7 +267,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(ftp_delete, arginfo_ftp_delete)
 	ZEND_FE(ftp_site, arginfo_ftp_site)
 	ZEND_FE(ftp_close, arginfo_ftp_close)
-	ZEND_FALIAS(ftp_quit, ftp_close, arginfo_ftp_quit)
+	ZEND_RAW_FENTRY("ftp_quit", zif_ftp_close, arginfo_ftp_quit, 0, NULL, NULL)
 	ZEND_FE(ftp_set_option, arginfo_ftp_set_option)
 	ZEND_FE(ftp_get_option, arginfo_ftp_get_option)
 	ZEND_FE_END
diff --git a/ext/gd/gd_arginfo.h b/ext/gd/gd_arginfo.h
index be5c40aa7b0bf..f68b34d5e101b 100644
--- a/ext/gd/gd_arginfo.h
+++ b/ext/gd/gd_arginfo.h
@@ -744,7 +744,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(imagesettile, arginfo_imagesettile)
 	ZEND_FE(imagesetbrush, arginfo_imagesetbrush)
 	ZEND_FE(imagecreate, arginfo_imagecreate)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(imagetypes, arginfo_imagetypes)
+	ZEND_RAW_FENTRY("imagetypes", zif_imagetypes, arginfo_imagetypes, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(imagecreatefromstring, arginfo_imagecreatefromstring)
 #if defined(HAVE_GD_AVIF)
 	ZEND_FE(imagecreatefromavif, arginfo_imagecreatefromavif)
@@ -841,10 +841,10 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(imagefttext, arginfo_imagefttext)
 #endif
 #if defined(HAVE_GD_FREETYPE)
-	ZEND_FALIAS(imagettfbbox, imageftbbox, arginfo_imagettfbbox)
+	ZEND_RAW_FENTRY("imagettfbbox", zif_imageftbbox, arginfo_imagettfbbox, 0, NULL, NULL)
 #endif
 #if defined(HAVE_GD_FREETYPE)
-	ZEND_FALIAS(imagettftext, imagefttext, arginfo_imagettftext)
+	ZEND_RAW_FENTRY("imagettftext", zif_imagefttext, arginfo_imagettftext, 0, NULL, NULL)
 #endif
 	ZEND_FE(imagefilter, arginfo_imagefilter)
 	ZEND_FE(imageconvolution, arginfo_imageconvolution)
diff --git a/ext/gettext/gettext_arginfo.h b/ext/gettext/gettext_arginfo.h
index 4c7fa10882808..8b2d7712dc87e 100644
--- a/ext/gettext/gettext_arginfo.h
+++ b/ext/gettext/gettext_arginfo.h
@@ -82,7 +82,7 @@ ZEND_FUNCTION(bind_textdomain_codeset);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(textdomain, arginfo_textdomain)
 	ZEND_FE(gettext, arginfo_gettext)
-	ZEND_FALIAS(_, gettext, arginfo__)
+	ZEND_RAW_FENTRY("_", zif_gettext, arginfo__, 0, NULL, NULL)
 	ZEND_FE(dgettext, arginfo_dgettext)
 	ZEND_FE(dcgettext, arginfo_dcgettext)
 	ZEND_FE(bindtextdomain, arginfo_bindtextdomain)
diff --git a/ext/gmp/gmp_arginfo.h b/ext/gmp/gmp_arginfo.h
index afc47978a8c10..8126fa6686731 100644
--- a/ext/gmp/gmp_arginfo.h
+++ b/ext/gmp/gmp_arginfo.h
@@ -262,7 +262,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(gmp_div_qr, arginfo_gmp_div_qr)
 	ZEND_FE(gmp_div_q, arginfo_gmp_div_q)
 	ZEND_FE(gmp_div_r, arginfo_gmp_div_r)
-	ZEND_FALIAS(gmp_div, gmp_div_q, arginfo_gmp_div)
+	ZEND_RAW_FENTRY("gmp_div", zif_gmp_div_q, arginfo_gmp_div, 0, NULL, NULL)
 	ZEND_FE(gmp_mod, arginfo_gmp_mod)
 	ZEND_FE(gmp_divexact, arginfo_gmp_divexact)
 	ZEND_FE(gmp_neg, arginfo_gmp_neg)
diff --git a/ext/hash/hash_arginfo.h b/ext/hash/hash_arginfo.h
index 116a0a4cf2b21..8c24a4009d69a 100644
--- a/ext/hash/hash_arginfo.h
+++ b/ext/hash/hash_arginfo.h
@@ -178,25 +178,25 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(hash_update_file, arginfo_hash_update_file)
 	ZEND_FE(hash_final, arginfo_hash_final)
 	ZEND_FE(hash_copy, arginfo_hash_copy)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(hash_algos, arginfo_hash_algos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(hash_hmac_algos, arginfo_hash_hmac_algos)
+	ZEND_RAW_FENTRY("hash_algos", zif_hash_algos, arginfo_hash_algos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("hash_hmac_algos", zif_hash_hmac_algos, arginfo_hash_hmac_algos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(hash_pbkdf2, arginfo_hash_pbkdf2)
 	ZEND_FE(hash_equals, arginfo_hash_equals)
 	ZEND_FE(hash_hkdf, arginfo_hash_hkdf)
 #if defined(PHP_MHASH_BC)
-	ZEND_DEP_FE(mhash_get_block_size, arginfo_mhash_get_block_size)
+	ZEND_RAW_FENTRY("mhash_get_block_size", zif_mhash_get_block_size, arginfo_mhash_get_block_size, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 #if defined(PHP_MHASH_BC)
-	ZEND_DEP_FE(mhash_get_hash_name, arginfo_mhash_get_hash_name)
+	ZEND_RAW_FENTRY("mhash_get_hash_name", zif_mhash_get_hash_name, arginfo_mhash_get_hash_name, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 #if defined(PHP_MHASH_BC)
-	ZEND_DEP_FE(mhash_keygen_s2k, arginfo_mhash_keygen_s2k)
+	ZEND_RAW_FENTRY("mhash_keygen_s2k", zif_mhash_keygen_s2k, arginfo_mhash_keygen_s2k, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 #if defined(PHP_MHASH_BC)
-	ZEND_DEP_FE(mhash_count, arginfo_mhash_count)
+	ZEND_RAW_FENTRY("mhash_count", zif_mhash_count, arginfo_mhash_count, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 #if defined(PHP_MHASH_BC)
-	ZEND_DEP_FE(mhash, arginfo_mhash)
+	ZEND_RAW_FENTRY("mhash", zif_mhash, arginfo_mhash, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 	ZEND_FE_END
 };
diff --git a/ext/intl/calendar/calendar_arginfo.h b/ext/intl/calendar/calendar_arginfo.h
index 9cdd6165a5599..f24b52dc83d30 100644
--- a/ext/intl/calendar/calendar_arginfo.h
+++ b/ext/intl/calendar/calendar_arginfo.h
@@ -260,53 +260,53 @@ ZEND_FUNCTION(intlgregcal_is_leap_year);
 
 static const zend_function_entry class_IntlCalendar_methods[] = {
 	ZEND_ME(IntlCalendar, __construct, arginfo_class_IntlCalendar___construct, ZEND_ACC_PRIVATE)
-	ZEND_ME_MAPPING(createInstance, intlcal_create_instance, arginfo_class_IntlCalendar_createInstance, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(equals, intlcal_equals, arginfo_class_IntlCalendar_equals, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fieldDifference, intlcal_field_difference, arginfo_class_IntlCalendar_fieldDifference, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(add, intlcal_add, arginfo_class_IntlCalendar_add, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(after, intlcal_after, arginfo_class_IntlCalendar_after, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(before, intlcal_before, arginfo_class_IntlCalendar_before, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(clear, intlcal_clear, arginfo_class_IntlCalendar_clear, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fromDateTime, intlcal_from_date_time, arginfo_class_IntlCalendar_fromDateTime, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(get, intlcal_get, arginfo_class_IntlCalendar_get, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getActualMaximum, intlcal_get_actual_maximum, arginfo_class_IntlCalendar_getActualMaximum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getActualMinimum, intlcal_get_actual_minimum, arginfo_class_IntlCalendar_getActualMinimum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getAvailableLocales, intlcal_get_available_locales, arginfo_class_IntlCalendar_getAvailableLocales, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDayOfWeekType, intlcal_get_day_of_week_type, arginfo_class_IntlCalendar_getDayOfWeekType, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, intlcal_get_error_code, arginfo_class_IntlCalendar_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, intlcal_get_error_message, arginfo_class_IntlCalendar_getErrorMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getFirstDayOfWeek, intlcal_get_first_day_of_week, arginfo_class_IntlCalendar_getFirstDayOfWeek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getGreatestMinimum, intlcal_get_greatest_minimum, arginfo_class_IntlCalendar_getGreatestMinimum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getKeywordValuesForLocale, intlcal_get_keyword_values_for_locale, arginfo_class_IntlCalendar_getKeywordValuesForLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getLeastMaximum, intlcal_get_least_maximum, arginfo_class_IntlCalendar_getLeastMaximum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocale, intlcal_get_locale, arginfo_class_IntlCalendar_getLocale, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getMaximum, intlcal_get_maximum, arginfo_class_IntlCalendar_getMaximum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getMinimalDaysInFirstWeek, intlcal_get_minimal_days_in_first_week, arginfo_class_IntlCalendar_getMinimalDaysInFirstWeek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setMinimalDaysInFirstWeek, intlcal_set_minimal_days_in_first_week, arginfo_class_IntlCalendar_setMinimalDaysInFirstWeek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getMinimum, intlcal_get_minimum, arginfo_class_IntlCalendar_getMinimum, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getNow, intlcal_get_now, arginfo_class_IntlCalendar_getNow, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getRepeatedWallTimeOption, intlcal_get_repeated_wall_time_option, arginfo_class_IntlCalendar_getRepeatedWallTimeOption, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getSkippedWallTimeOption, intlcal_get_skipped_wall_time_option, arginfo_class_IntlCalendar_getSkippedWallTimeOption, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTime, intlcal_get_time, arginfo_class_IntlCalendar_getTime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimeZone, intlcal_get_time_zone, arginfo_class_IntlCalendar_getTimeZone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getType, intlcal_get_type, arginfo_class_IntlCalendar_getType, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getWeekendTransition, intlcal_get_weekend_transition, arginfo_class_IntlCalendar_getWeekendTransition, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(inDaylightTime, intlcal_in_daylight_time, arginfo_class_IntlCalendar_inDaylightTime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isEquivalentTo, intlcal_is_equivalent_to, arginfo_class_IntlCalendar_isEquivalentTo, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isLenient, intlcal_is_lenient, arginfo_class_IntlCalendar_isLenient, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isWeekend, intlcal_is_weekend, arginfo_class_IntlCalendar_isWeekend, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(roll, intlcal_roll, arginfo_class_IntlCalendar_roll, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isSet, intlcal_is_set, arginfo_class_IntlCalendar_isSet, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(set, intlcal_set, arginfo_class_IntlCalendar_set, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("createInstance", zif_intlcal_create_instance, arginfo_class_IntlCalendar_createInstance, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("equals", zif_intlcal_equals, arginfo_class_IntlCalendar_equals, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fieldDifference", zif_intlcal_field_difference, arginfo_class_IntlCalendar_fieldDifference, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("add", zif_intlcal_add, arginfo_class_IntlCalendar_add, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("after", zif_intlcal_after, arginfo_class_IntlCalendar_after, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("before", zif_intlcal_before, arginfo_class_IntlCalendar_before, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("clear", zif_intlcal_clear, arginfo_class_IntlCalendar_clear, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fromDateTime", zif_intlcal_from_date_time, arginfo_class_IntlCalendar_fromDateTime, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get", zif_intlcal_get, arginfo_class_IntlCalendar_get, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getActualMaximum", zif_intlcal_get_actual_maximum, arginfo_class_IntlCalendar_getActualMaximum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getActualMinimum", zif_intlcal_get_actual_minimum, arginfo_class_IntlCalendar_getActualMinimum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getAvailableLocales", zif_intlcal_get_available_locales, arginfo_class_IntlCalendar_getAvailableLocales, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDayOfWeekType", zif_intlcal_get_day_of_week_type, arginfo_class_IntlCalendar_getDayOfWeekType, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_intlcal_get_error_code, arginfo_class_IntlCalendar_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_intlcal_get_error_message, arginfo_class_IntlCalendar_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getFirstDayOfWeek", zif_intlcal_get_first_day_of_week, arginfo_class_IntlCalendar_getFirstDayOfWeek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getGreatestMinimum", zif_intlcal_get_greatest_minimum, arginfo_class_IntlCalendar_getGreatestMinimum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getKeywordValuesForLocale", zif_intlcal_get_keyword_values_for_locale, arginfo_class_IntlCalendar_getKeywordValuesForLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLeastMaximum", zif_intlcal_get_least_maximum, arginfo_class_IntlCalendar_getLeastMaximum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocale", zif_intlcal_get_locale, arginfo_class_IntlCalendar_getLocale, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMaximum", zif_intlcal_get_maximum, arginfo_class_IntlCalendar_getMaximum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMinimalDaysInFirstWeek", zif_intlcal_get_minimal_days_in_first_week, arginfo_class_IntlCalendar_getMinimalDaysInFirstWeek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setMinimalDaysInFirstWeek", zif_intlcal_set_minimal_days_in_first_week, arginfo_class_IntlCalendar_setMinimalDaysInFirstWeek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMinimum", zif_intlcal_get_minimum, arginfo_class_IntlCalendar_getMinimum, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getNow", zif_intlcal_get_now, arginfo_class_IntlCalendar_getNow, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getRepeatedWallTimeOption", zif_intlcal_get_repeated_wall_time_option, arginfo_class_IntlCalendar_getRepeatedWallTimeOption, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getSkippedWallTimeOption", zif_intlcal_get_skipped_wall_time_option, arginfo_class_IntlCalendar_getSkippedWallTimeOption, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTime", zif_intlcal_get_time, arginfo_class_IntlCalendar_getTime, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimeZone", zif_intlcal_get_time_zone, arginfo_class_IntlCalendar_getTimeZone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getType", zif_intlcal_get_type, arginfo_class_IntlCalendar_getType, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getWeekendTransition", zif_intlcal_get_weekend_transition, arginfo_class_IntlCalendar_getWeekendTransition, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("inDaylightTime", zif_intlcal_in_daylight_time, arginfo_class_IntlCalendar_inDaylightTime, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isEquivalentTo", zif_intlcal_is_equivalent_to, arginfo_class_IntlCalendar_isEquivalentTo, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isLenient", zif_intlcal_is_lenient, arginfo_class_IntlCalendar_isLenient, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isWeekend", zif_intlcal_is_weekend, arginfo_class_IntlCalendar_isWeekend, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("roll", zif_intlcal_roll, arginfo_class_IntlCalendar_roll, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isSet", zif_intlcal_is_set, arginfo_class_IntlCalendar_isSet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("set", zif_intlcal_set, arginfo_class_IntlCalendar_set, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(IntlCalendar, setDate, arginfo_class_IntlCalendar_setDate, ZEND_ACC_PUBLIC)
 	ZEND_ME(IntlCalendar, setDateTime, arginfo_class_IntlCalendar_setDateTime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setFirstDayOfWeek, intlcal_set_first_day_of_week, arginfo_class_IntlCalendar_setFirstDayOfWeek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setLenient, intlcal_set_lenient, arginfo_class_IntlCalendar_setLenient, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setRepeatedWallTimeOption, intlcal_set_repeated_wall_time_option, arginfo_class_IntlCalendar_setRepeatedWallTimeOption, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setSkippedWallTimeOption, intlcal_set_skipped_wall_time_option, arginfo_class_IntlCalendar_setSkippedWallTimeOption, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTime, intlcal_set_time, arginfo_class_IntlCalendar_setTime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTimeZone, intlcal_set_time_zone, arginfo_class_IntlCalendar_setTimeZone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(toDateTime, intlcal_to_date_time, arginfo_class_IntlCalendar_toDateTime, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("setFirstDayOfWeek", zif_intlcal_set_first_day_of_week, arginfo_class_IntlCalendar_setFirstDayOfWeek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setLenient", zif_intlcal_set_lenient, arginfo_class_IntlCalendar_setLenient, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setRepeatedWallTimeOption", zif_intlcal_set_repeated_wall_time_option, arginfo_class_IntlCalendar_setRepeatedWallTimeOption, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setSkippedWallTimeOption", zif_intlcal_set_skipped_wall_time_option, arginfo_class_IntlCalendar_setSkippedWallTimeOption, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTime", zif_intlcal_set_time, arginfo_class_IntlCalendar_setTime, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTimeZone", zif_intlcal_set_time_zone, arginfo_class_IntlCalendar_setTimeZone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("toDateTime", zif_intlcal_to_date_time, arginfo_class_IntlCalendar_toDateTime, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -314,9 +314,9 @@ static const zend_function_entry class_IntlGregorianCalendar_methods[] = {
 	ZEND_ME(IntlGregorianCalendar, createFromDate, arginfo_class_IntlGregorianCalendar_createFromDate, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(IntlGregorianCalendar, createFromDateTime, arginfo_class_IntlGregorianCalendar_createFromDateTime, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(IntlGregorianCalendar, __construct, arginfo_class_IntlGregorianCalendar___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setGregorianChange, intlgregcal_set_gregorian_change, arginfo_class_IntlGregorianCalendar_setGregorianChange, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getGregorianChange, intlgregcal_get_gregorian_change, arginfo_class_IntlGregorianCalendar_getGregorianChange, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isLeapYear, intlgregcal_is_leap_year, arginfo_class_IntlGregorianCalendar_isLeapYear, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("setGregorianChange", zif_intlgregcal_set_gregorian_change, arginfo_class_IntlGregorianCalendar_setGregorianChange, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getGregorianChange", zif_intlgregcal_get_gregorian_change, arginfo_class_IntlGregorianCalendar_getGregorianChange, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isLeapYear", zif_intlgregcal_is_leap_year, arginfo_class_IntlGregorianCalendar_isLeapYear, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/collator/collator_arginfo.h b/ext/intl/collator/collator_arginfo.h
index 357bfc023b714..68f87da00f9de 100644
--- a/ext/intl/collator/collator_arginfo.h
+++ b/ext/intl/collator/collator_arginfo.h
@@ -72,19 +72,19 @@ ZEND_FUNCTION(collator_get_sort_key);
 
 static const zend_function_entry class_Collator_methods[] = {
 	ZEND_ME(Collator, __construct, arginfo_class_Collator___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(create, collator_create, arginfo_class_Collator_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(compare, collator_compare, arginfo_class_Collator_compare, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(sort, collator_sort, arginfo_class_Collator_sort, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(sortWithSortKeys, collator_sort_with_sort_keys, arginfo_class_Collator_sortWithSortKeys, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(asort, collator_asort, arginfo_class_Collator_asort, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getAttribute, collator_get_attribute, arginfo_class_Collator_getAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setAttribute, collator_set_attribute, arginfo_class_Collator_setAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getStrength, collator_get_strength, arginfo_class_Collator_getStrength, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setStrength, collator_set_strength, arginfo_class_Collator_setStrength, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocale, collator_get_locale, arginfo_class_Collator_getLocale, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, collator_get_error_code, arginfo_class_Collator_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, collator_get_error_message, arginfo_class_Collator_getErrorMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getSortKey, collator_get_sort_key, arginfo_class_Collator_getSortKey, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_collator_create, arginfo_class_Collator_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("compare", zif_collator_compare, arginfo_class_Collator_compare, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("sort", zif_collator_sort, arginfo_class_Collator_sort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("sortWithSortKeys", zif_collator_sort_with_sort_keys, arginfo_class_Collator_sortWithSortKeys, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("asort", zif_collator_asort, arginfo_class_Collator_asort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getAttribute", zif_collator_get_attribute, arginfo_class_Collator_getAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setAttribute", zif_collator_set_attribute, arginfo_class_Collator_setAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getStrength", zif_collator_get_strength, arginfo_class_Collator_getStrength, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setStrength", zif_collator_set_strength, arginfo_class_Collator_setStrength, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocale", zif_collator_get_locale, arginfo_class_Collator_getLocale, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_collator_get_error_code, arginfo_class_Collator_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_collator_get_error_message, arginfo_class_Collator_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getSortKey", zif_collator_get_sort_key, arginfo_class_Collator_getSortKey, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/dateformat/dateformat_arginfo.h b/ext/intl/dateformat/dateformat_arginfo.h
index e6da25b068d03..4d16a26ef1673 100644
--- a/ext/intl/dateformat/dateformat_arginfo.h
+++ b/ext/intl/dateformat/dateformat_arginfo.h
@@ -110,26 +110,26 @@ ZEND_FUNCTION(datefmt_get_error_message);
 
 static const zend_function_entry class_IntlDateFormatter_methods[] = {
 	ZEND_ME(IntlDateFormatter, __construct, arginfo_class_IntlDateFormatter___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(create, datefmt_create, arginfo_class_IntlDateFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDateType, datefmt_get_datetype, arginfo_class_IntlDateFormatter_getDateType, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimeType, datefmt_get_timetype, arginfo_class_IntlDateFormatter_getTimeType, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getCalendar, datefmt_get_calendar, arginfo_class_IntlDateFormatter_getCalendar, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setCalendar, datefmt_set_calendar, arginfo_class_IntlDateFormatter_setCalendar, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimeZoneId, datefmt_get_timezone_id, arginfo_class_IntlDateFormatter_getTimeZoneId, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getCalendarObject, datefmt_get_calendar_object, arginfo_class_IntlDateFormatter_getCalendarObject, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTimeZone, datefmt_get_timezone, arginfo_class_IntlDateFormatter_getTimeZone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTimeZone, datefmt_set_timezone, arginfo_class_IntlDateFormatter_setTimeZone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setPattern, datefmt_set_pattern, arginfo_class_IntlDateFormatter_setPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getPattern, datefmt_get_pattern, arginfo_class_IntlDateFormatter_getPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocale, datefmt_get_locale, arginfo_class_IntlDateFormatter_getLocale, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setLenient, datefmt_set_lenient, arginfo_class_IntlDateFormatter_setLenient, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isLenient, datefmt_is_lenient, arginfo_class_IntlDateFormatter_isLenient, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(format, datefmt_format, arginfo_class_IntlDateFormatter_format, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(formatObject, datefmt_format_object, arginfo_class_IntlDateFormatter_formatObject, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(parse, datefmt_parse, arginfo_class_IntlDateFormatter_parse, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(localtime, datefmt_localtime, arginfo_class_IntlDateFormatter_localtime, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, datefmt_get_error_code, arginfo_class_IntlDateFormatter_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, datefmt_get_error_message, arginfo_class_IntlDateFormatter_getErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_datefmt_create, arginfo_class_IntlDateFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDateType", zif_datefmt_get_datetype, arginfo_class_IntlDateFormatter_getDateType, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimeType", zif_datefmt_get_timetype, arginfo_class_IntlDateFormatter_getTimeType, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getCalendar", zif_datefmt_get_calendar, arginfo_class_IntlDateFormatter_getCalendar, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setCalendar", zif_datefmt_set_calendar, arginfo_class_IntlDateFormatter_setCalendar, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimeZoneId", zif_datefmt_get_timezone_id, arginfo_class_IntlDateFormatter_getTimeZoneId, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getCalendarObject", zif_datefmt_get_calendar_object, arginfo_class_IntlDateFormatter_getCalendarObject, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTimeZone", zif_datefmt_get_timezone, arginfo_class_IntlDateFormatter_getTimeZone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTimeZone", zif_datefmt_set_timezone, arginfo_class_IntlDateFormatter_setTimeZone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setPattern", zif_datefmt_set_pattern, arginfo_class_IntlDateFormatter_setPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getPattern", zif_datefmt_get_pattern, arginfo_class_IntlDateFormatter_getPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocale", zif_datefmt_get_locale, arginfo_class_IntlDateFormatter_getLocale, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setLenient", zif_datefmt_set_lenient, arginfo_class_IntlDateFormatter_setLenient, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isLenient", zif_datefmt_is_lenient, arginfo_class_IntlDateFormatter_isLenient, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("format", zif_datefmt_format, arginfo_class_IntlDateFormatter_format, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("formatObject", zif_datefmt_format_object, arginfo_class_IntlDateFormatter_formatObject, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parse", zif_datefmt_parse, arginfo_class_IntlDateFormatter_parse, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("localtime", zif_datefmt_localtime, arginfo_class_IntlDateFormatter_localtime, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_datefmt_get_error_code, arginfo_class_IntlDateFormatter_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_datefmt_get_error_message, arginfo_class_IntlDateFormatter_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/formatter/formatter_arginfo.h b/ext/intl/formatter/formatter_arginfo.h
index 0ed0b1d84ae77..1942b342ecb90 100644
--- a/ext/intl/formatter/formatter_arginfo.h
+++ b/ext/intl/formatter/formatter_arginfo.h
@@ -99,22 +99,22 @@ ZEND_FUNCTION(numfmt_get_error_message);
 
 static const zend_function_entry class_NumberFormatter_methods[] = {
 	ZEND_ME(NumberFormatter, __construct, arginfo_class_NumberFormatter___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(create, numfmt_create, arginfo_class_NumberFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(format, numfmt_format, arginfo_class_NumberFormatter_format, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(parse, numfmt_parse, arginfo_class_NumberFormatter_parse, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(formatCurrency, numfmt_format_currency, arginfo_class_NumberFormatter_formatCurrency, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(parseCurrency, numfmt_parse_currency, arginfo_class_NumberFormatter_parseCurrency, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setAttribute, numfmt_set_attribute, arginfo_class_NumberFormatter_setAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getAttribute, numfmt_get_attribute, arginfo_class_NumberFormatter_getAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setTextAttribute, numfmt_set_text_attribute, arginfo_class_NumberFormatter_setTextAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getTextAttribute, numfmt_get_text_attribute, arginfo_class_NumberFormatter_getTextAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setSymbol, numfmt_set_symbol, arginfo_class_NumberFormatter_setSymbol, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getSymbol, numfmt_get_symbol, arginfo_class_NumberFormatter_getSymbol, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setPattern, numfmt_set_pattern, arginfo_class_NumberFormatter_setPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getPattern, numfmt_get_pattern, arginfo_class_NumberFormatter_getPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocale, numfmt_get_locale, arginfo_class_NumberFormatter_getLocale, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, numfmt_get_error_code, arginfo_class_NumberFormatter_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, numfmt_get_error_message, arginfo_class_NumberFormatter_getErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_numfmt_create, arginfo_class_NumberFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("format", zif_numfmt_format, arginfo_class_NumberFormatter_format, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parse", zif_numfmt_parse, arginfo_class_NumberFormatter_parse, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("formatCurrency", zif_numfmt_format_currency, arginfo_class_NumberFormatter_formatCurrency, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parseCurrency", zif_numfmt_parse_currency, arginfo_class_NumberFormatter_parseCurrency, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setAttribute", zif_numfmt_set_attribute, arginfo_class_NumberFormatter_setAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getAttribute", zif_numfmt_get_attribute, arginfo_class_NumberFormatter_getAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setTextAttribute", zif_numfmt_set_text_attribute, arginfo_class_NumberFormatter_setTextAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTextAttribute", zif_numfmt_get_text_attribute, arginfo_class_NumberFormatter_getTextAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setSymbol", zif_numfmt_set_symbol, arginfo_class_NumberFormatter_setSymbol, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getSymbol", zif_numfmt_get_symbol, arginfo_class_NumberFormatter_getSymbol, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setPattern", zif_numfmt_set_pattern, arginfo_class_NumberFormatter_setPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getPattern", zif_numfmt_get_pattern, arginfo_class_NumberFormatter_getPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocale", zif_numfmt_get_locale, arginfo_class_NumberFormatter_getLocale, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_numfmt_get_error_code, arginfo_class_NumberFormatter_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_numfmt_get_error_message, arginfo_class_NumberFormatter_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/locale/locale_arginfo.h b/ext/intl/locale/locale_arginfo.h
index fa55d8fa22d69..3e38096eb5808 100644
--- a/ext/intl/locale/locale_arginfo.h
+++ b/ext/intl/locale/locale_arginfo.h
@@ -82,24 +82,24 @@ ZEND_FUNCTION(locale_canonicalize);
 ZEND_FUNCTION(locale_accept_from_http);
 
 static const zend_function_entry class_Locale_methods[] = {
-	ZEND_ME_MAPPING(getDefault, locale_get_default, arginfo_class_Locale_getDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(setDefault, locale_set_default, arginfo_class_Locale_setDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getPrimaryLanguage, locale_get_primary_language, arginfo_class_Locale_getPrimaryLanguage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getScript, locale_get_script, arginfo_class_Locale_getScript, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getRegion, locale_get_region, arginfo_class_Locale_getRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getKeywords, locale_get_keywords, arginfo_class_Locale_getKeywords, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayScript, locale_get_display_script, arginfo_class_Locale_getDisplayScript, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayRegion, locale_get_display_region, arginfo_class_Locale_getDisplayRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayName, locale_get_display_name, arginfo_class_Locale_getDisplayName, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayLanguage, locale_get_display_language, arginfo_class_Locale_getDisplayLanguage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayVariant, locale_get_display_variant, arginfo_class_Locale_getDisplayVariant, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(composeLocale, locale_compose, arginfo_class_Locale_composeLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(parseLocale, locale_parse, arginfo_class_Locale_parseLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getAllVariants, locale_get_all_variants, arginfo_class_Locale_getAllVariants, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(filterMatches, locale_filter_matches, arginfo_class_Locale_filterMatches, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(lookup, locale_lookup, arginfo_class_Locale_lookup, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(canonicalize, locale_canonicalize, arginfo_class_Locale_canonicalize, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(acceptFromHttp, locale_accept_from_http, arginfo_class_Locale_acceptFromHttp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getDefault", zif_locale_get_default, arginfo_class_Locale_getDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setDefault", zif_locale_set_default, arginfo_class_Locale_setDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getPrimaryLanguage", zif_locale_get_primary_language, arginfo_class_Locale_getPrimaryLanguage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getScript", zif_locale_get_script, arginfo_class_Locale_getScript, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getRegion", zif_locale_get_region, arginfo_class_Locale_getRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getKeywords", zif_locale_get_keywords, arginfo_class_Locale_getKeywords, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayScript", zif_locale_get_display_script, arginfo_class_Locale_getDisplayScript, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayRegion", zif_locale_get_display_region, arginfo_class_Locale_getDisplayRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayName", zif_locale_get_display_name, arginfo_class_Locale_getDisplayName, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayLanguage", zif_locale_get_display_language, arginfo_class_Locale_getDisplayLanguage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayVariant", zif_locale_get_display_variant, arginfo_class_Locale_getDisplayVariant, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("composeLocale", zif_locale_compose, arginfo_class_Locale_composeLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parseLocale", zif_locale_parse, arginfo_class_Locale_parseLocale, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getAllVariants", zif_locale_get_all_variants, arginfo_class_Locale_getAllVariants, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("filterMatches", zif_locale_filter_matches, arginfo_class_Locale_filterMatches, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("lookup", zif_locale_lookup, arginfo_class_Locale_lookup, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("canonicalize", zif_locale_canonicalize, arginfo_class_Locale_canonicalize, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("acceptFromHttp", zif_locale_accept_from_http, arginfo_class_Locale_acceptFromHttp, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/msgformat/msgformat_arginfo.h b/ext/intl/msgformat/msgformat_arginfo.h
index ee8122f5a0681..bc45b5b535de5 100644
--- a/ext/intl/msgformat/msgformat_arginfo.h
+++ b/ext/intl/msgformat/msgformat_arginfo.h
@@ -60,16 +60,16 @@ ZEND_FUNCTION(msgfmt_get_error_message);
 
 static const zend_function_entry class_MessageFormatter_methods[] = {
 	ZEND_ME(MessageFormatter, __construct, arginfo_class_MessageFormatter___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(create, msgfmt_create, arginfo_class_MessageFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(format, msgfmt_format, arginfo_class_MessageFormatter_format, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(formatMessage, msgfmt_format_message, arginfo_class_MessageFormatter_formatMessage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(parse, msgfmt_parse, arginfo_class_MessageFormatter_parse, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(parseMessage, msgfmt_parse_message, arginfo_class_MessageFormatter_parseMessage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(setPattern, msgfmt_set_pattern, arginfo_class_MessageFormatter_setPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getPattern, msgfmt_get_pattern, arginfo_class_MessageFormatter_getPattern, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocale, msgfmt_get_locale, arginfo_class_MessageFormatter_getLocale, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, msgfmt_get_error_code, arginfo_class_MessageFormatter_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, msgfmt_get_error_message, arginfo_class_MessageFormatter_getErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_msgfmt_create, arginfo_class_MessageFormatter_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("format", zif_msgfmt_format, arginfo_class_MessageFormatter_format, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("formatMessage", zif_msgfmt_format_message, arginfo_class_MessageFormatter_formatMessage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parse", zif_msgfmt_parse, arginfo_class_MessageFormatter_parse, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("parseMessage", zif_msgfmt_parse_message, arginfo_class_MessageFormatter_parseMessage, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setPattern", zif_msgfmt_set_pattern, arginfo_class_MessageFormatter_setPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getPattern", zif_msgfmt_get_pattern, arginfo_class_MessageFormatter_getPattern, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocale", zif_msgfmt_get_locale, arginfo_class_MessageFormatter_getLocale, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_msgfmt_get_error_code, arginfo_class_MessageFormatter_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_msgfmt_get_error_message, arginfo_class_MessageFormatter_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/normalizer/normalizer_arginfo.h b/ext/intl/normalizer/normalizer_arginfo.h
index 73738be445615..a7a870a60d55e 100644
--- a/ext/intl/normalizer/normalizer_arginfo.h
+++ b/ext/intl/normalizer/normalizer_arginfo.h
@@ -25,10 +25,10 @@ ZEND_FUNCTION(normalizer_get_raw_decomposition);
 #endif
 
 static const zend_function_entry class_Normalizer_methods[] = {
-	ZEND_ME_MAPPING(normalize, normalizer_normalize, arginfo_class_Normalizer_normalize, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(isNormalized, normalizer_is_normalized, arginfo_class_Normalizer_isNormalized, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("normalize", zif_normalizer_normalize, arginfo_class_Normalizer_normalize, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isNormalized", zif_normalizer_is_normalized, arginfo_class_Normalizer_isNormalized, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #if U_ICU_VERSION_MAJOR_NUM >= 56
-	ZEND_ME_MAPPING(getRawDecomposition, normalizer_get_raw_decomposition, arginfo_class_Normalizer_getRawDecomposition, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getRawDecomposition", zif_normalizer_get_raw_decomposition, arginfo_class_Normalizer_getRawDecomposition, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #endif
 	ZEND_FE_END
 };
diff --git a/ext/intl/php_intl_arginfo.h b/ext/intl/php_intl_arginfo.h
index 32eee78bb094d..f26d802a7eb4e 100644
--- a/ext/intl/php_intl_arginfo.h
+++ b/ext/intl/php_intl_arginfo.h
@@ -994,7 +994,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(intlcal_set_time_zone, arginfo_intlcal_set_time_zone)
 	ZEND_FE(intlcal_after, arginfo_intlcal_after)
 	ZEND_FE(intlcal_before, arginfo_intlcal_before)
-	ZEND_DEP_FE(intlcal_set, arginfo_intlcal_set)
+	ZEND_RAW_FENTRY("intlcal_set", zif_intlcal_set, arginfo_intlcal_set, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(intlcal_roll, arginfo_intlcal_roll)
 	ZEND_FE(intlcal_clear, arginfo_intlcal_clear)
 	ZEND_FE(intlcal_field_difference, arginfo_intlcal_field_difference)
@@ -1028,7 +1028,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(intlcal_to_date_time, arginfo_intlcal_to_date_time)
 	ZEND_FE(intlcal_get_error_code, arginfo_intlcal_get_error_code)
 	ZEND_FE(intlcal_get_error_message, arginfo_intlcal_get_error_message)
-	ZEND_DEP_FE(intlgregcal_create_instance, arginfo_intlgregcal_create_instance)
+	ZEND_RAW_FENTRY("intlgregcal_create_instance", zif_intlgregcal_create_instance, arginfo_intlgregcal_create_instance, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(intlgregcal_set_gregorian_change, arginfo_intlgregcal_set_gregorian_change)
 	ZEND_FE(intlgregcal_get_gregorian_change, arginfo_intlgregcal_get_gregorian_change)
 	ZEND_FE(intlgregcal_is_leap_year, arginfo_intlgregcal_is_leap_year)
diff --git a/ext/intl/resourcebundle/resourcebundle_arginfo.h b/ext/intl/resourcebundle/resourcebundle_arginfo.h
index d867560ebd1e3..8a338a466e866 100644
--- a/ext/intl/resourcebundle/resourcebundle_arginfo.h
+++ b/ext/intl/resourcebundle/resourcebundle_arginfo.h
@@ -44,12 +44,12 @@ ZEND_METHOD(ResourceBundle, getIterator);
 
 static const zend_function_entry class_ResourceBundle_methods[] = {
 	ZEND_ME(ResourceBundle, __construct, arginfo_class_ResourceBundle___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(create, resourcebundle_create, arginfo_class_ResourceBundle_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(get, resourcebundle_get, arginfo_class_ResourceBundle_get, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(count, resourcebundle_count, arginfo_class_ResourceBundle_count, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getLocales, resourcebundle_locales, arginfo_class_ResourceBundle_getLocales, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getErrorCode, resourcebundle_get_error_code, arginfo_class_ResourceBundle_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, resourcebundle_get_error_message, arginfo_class_ResourceBundle_getErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_resourcebundle_create, arginfo_class_ResourceBundle_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get", zif_resourcebundle_get, arginfo_class_ResourceBundle_get, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("count", zif_resourcebundle_count, arginfo_class_ResourceBundle_count, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getLocales", zif_resourcebundle_locales, arginfo_class_ResourceBundle_getLocales, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_resourcebundle_get_error_code, arginfo_class_ResourceBundle_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_resourcebundle_get_error_message, arginfo_class_ResourceBundle_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(ResourceBundle, getIterator, arginfo_class_ResourceBundle_getIterator, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
diff --git a/ext/intl/timezone/timezone_arginfo.h b/ext/intl/timezone/timezone_arginfo.h
index 0622bb4865c83..023346526a00e 100644
--- a/ext/intl/timezone/timezone_arginfo.h
+++ b/ext/intl/timezone/timezone_arginfo.h
@@ -139,37 +139,37 @@ ZEND_FUNCTION(intltz_use_daylight_time);
 
 static const zend_function_entry class_IntlTimeZone_methods[] = {
 	ZEND_ME(IntlTimeZone, __construct, arginfo_class_IntlTimeZone___construct, ZEND_ACC_PRIVATE)
-	ZEND_ME_MAPPING(countEquivalentIDs, intltz_count_equivalent_ids, arginfo_class_IntlTimeZone_countEquivalentIDs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createDefault, intltz_create_default, arginfo_class_IntlTimeZone_createDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createEnumeration, intltz_create_enumeration, arginfo_class_IntlTimeZone_createEnumeration, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createTimeZone, intltz_create_time_zone, arginfo_class_IntlTimeZone_createTimeZone, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createTimeZoneIDEnumeration, intltz_create_time_zone_id_enumeration, arginfo_class_IntlTimeZone_createTimeZoneIDEnumeration, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(fromDateTimeZone, intltz_from_date_time_zone, arginfo_class_IntlTimeZone_fromDateTimeZone, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getCanonicalID, intltz_get_canonical_id, arginfo_class_IntlTimeZone_getCanonicalID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getDisplayName, intltz_get_display_name, arginfo_class_IntlTimeZone_getDisplayName, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getDSTSavings, intltz_get_dst_savings, arginfo_class_IntlTimeZone_getDSTSavings, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getEquivalentID, intltz_get_equivalent_id, arginfo_class_IntlTimeZone_getEquivalentID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getErrorCode, intltz_get_error_code, arginfo_class_IntlTimeZone_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, intltz_get_error_message, arginfo_class_IntlTimeZone_getErrorMessage, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getGMT, intltz_get_gmt, arginfo_class_IntlTimeZone_getGMT, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("countEquivalentIDs", zif_intltz_count_equivalent_ids, arginfo_class_IntlTimeZone_countEquivalentIDs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createDefault", zif_intltz_create_default, arginfo_class_IntlTimeZone_createDefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createEnumeration", zif_intltz_create_enumeration, arginfo_class_IntlTimeZone_createEnumeration, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createTimeZone", zif_intltz_create_time_zone, arginfo_class_IntlTimeZone_createTimeZone, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createTimeZoneIDEnumeration", zif_intltz_create_time_zone_id_enumeration, arginfo_class_IntlTimeZone_createTimeZoneIDEnumeration, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fromDateTimeZone", zif_intltz_from_date_time_zone, arginfo_class_IntlTimeZone_fromDateTimeZone, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getCanonicalID", zif_intltz_get_canonical_id, arginfo_class_IntlTimeZone_getCanonicalID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDisplayName", zif_intltz_get_display_name, arginfo_class_IntlTimeZone_getDisplayName, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getDSTSavings", zif_intltz_get_dst_savings, arginfo_class_IntlTimeZone_getDSTSavings, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getEquivalentID", zif_intltz_get_equivalent_id, arginfo_class_IntlTimeZone_getEquivalentID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_intltz_get_error_code, arginfo_class_IntlTimeZone_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_intltz_get_error_message, arginfo_class_IntlTimeZone_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getGMT", zif_intltz_get_gmt, arginfo_class_IntlTimeZone_getGMT, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #if U_ICU_VERSION_MAJOR_NUM >= 74
-	ZEND_ME_MAPPING(getIanaID, intltz_get_iana_id, arginfo_class_IntlTimeZone_getIanaID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getIanaID", zif_intltz_get_iana_id, arginfo_class_IntlTimeZone_getIanaID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #endif
-	ZEND_ME_MAPPING(getID, intltz_get_id, arginfo_class_IntlTimeZone_getID, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getOffset, intltz_get_offset, arginfo_class_IntlTimeZone_getOffset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getRawOffset, intltz_get_raw_offset, arginfo_class_IntlTimeZone_getRawOffset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getRegion, intltz_get_region, arginfo_class_IntlTimeZone_getRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getTZDataVersion, intltz_get_tz_data_version, arginfo_class_IntlTimeZone_getTZDataVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(getUnknown, intltz_get_unknown, arginfo_class_IntlTimeZone_getUnknown, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getID", zif_intltz_get_id, arginfo_class_IntlTimeZone_getID, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getOffset", zif_intltz_get_offset, arginfo_class_IntlTimeZone_getOffset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getRawOffset", zif_intltz_get_raw_offset, arginfo_class_IntlTimeZone_getRawOffset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getRegion", zif_intltz_get_region, arginfo_class_IntlTimeZone_getRegion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getTZDataVersion", zif_intltz_get_tz_data_version, arginfo_class_IntlTimeZone_getTZDataVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getUnknown", zif_intltz_get_unknown, arginfo_class_IntlTimeZone_getUnknown, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #if U_ICU_VERSION_MAJOR_NUM >= 52
-	ZEND_ME_MAPPING(getWindowsID, intltz_get_windows_id, arginfo_class_IntlTimeZone_getWindowsID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getWindowsID", zif_intltz_get_windows_id, arginfo_class_IntlTimeZone_getWindowsID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #endif
 #if U_ICU_VERSION_MAJOR_NUM >= 52
-	ZEND_ME_MAPPING(getIDForWindowsID, intltz_get_id_for_windows_id, arginfo_class_IntlTimeZone_getIDForWindowsID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+	ZEND_RAW_FENTRY("getIDForWindowsID", zif_intltz_get_id_for_windows_id, arginfo_class_IntlTimeZone_getIDForWindowsID, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
 #endif
-	ZEND_ME_MAPPING(hasSameRules, intltz_has_same_rules, arginfo_class_IntlTimeZone_hasSameRules, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(toDateTimeZone, intltz_to_date_time_zone, arginfo_class_IntlTimeZone_toDateTimeZone, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(useDaylightTime, intltz_use_daylight_time, arginfo_class_IntlTimeZone_useDaylightTime, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("hasSameRules", zif_intltz_has_same_rules, arginfo_class_IntlTimeZone_hasSameRules, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("toDateTimeZone", zif_intltz_to_date_time_zone, arginfo_class_IntlTimeZone_toDateTimeZone, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("useDaylightTime", zif_intltz_use_daylight_time, arginfo_class_IntlTimeZone_useDaylightTime, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/intl/transliterator/transliterator_arginfo.h b/ext/intl/transliterator/transliterator_arginfo.h
index 54fc0be6145c4..ee39917117172 100644
--- a/ext/intl/transliterator/transliterator_arginfo.h
+++ b/ext/intl/transliterator/transliterator_arginfo.h
@@ -43,13 +43,13 @@ ZEND_FUNCTION(transliterator_get_error_message);
 
 static const zend_function_entry class_Transliterator_methods[] = {
 	ZEND_ME(Transliterator, __construct, arginfo_class_Transliterator___construct, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
-	ZEND_ME_MAPPING(create, transliterator_create, arginfo_class_Transliterator_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createFromRules, transliterator_create_from_rules, arginfo_class_Transliterator_createFromRules, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(createInverse, transliterator_create_inverse, arginfo_class_Transliterator_createInverse, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(listIDs, transliterator_list_ids, arginfo_class_Transliterator_listIDs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(transliterate, transliterator_transliterate, arginfo_class_Transliterator_transliterate, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorCode, transliterator_get_error_code, arginfo_class_Transliterator_getErrorCode, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getErrorMessage, transliterator_get_error_message, arginfo_class_Transliterator_getErrorMessage, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("create", zif_transliterator_create, arginfo_class_Transliterator_create, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createFromRules", zif_transliterator_create_from_rules, arginfo_class_Transliterator_createFromRules, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("createInverse", zif_transliterator_create_inverse, arginfo_class_Transliterator_createInverse, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("listIDs", zif_transliterator_list_ids, arginfo_class_Transliterator_listIDs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("transliterate", zif_transliterator_transliterate, arginfo_class_Transliterator_transliterate, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorCode", zif_transliterator_get_error_code, arginfo_class_Transliterator_getErrorCode, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getErrorMessage", zif_transliterator_get_error_message, arginfo_class_Transliterator_getErrorMessage, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/json/json_arginfo.h b/ext/json/json_arginfo.h
index 5fe87b59c71ce..a02cfd4a78105 100644
--- a/ext/json/json_arginfo.h
+++ b/ext/json/json_arginfo.h
@@ -45,7 +45,7 @@ static const zend_function_entry ext_functions[] = {
 };
 
 static const zend_function_entry class_JsonSerializable_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(JsonSerializable, jsonSerialize, arginfo_class_JsonSerializable_jsonSerialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("jsonSerialize", NULL, arginfo_class_JsonSerializable_jsonSerialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/ldap/ldap_arginfo.h b/ext/ldap/ldap_arginfo.h
index eb988986efd8e..8993ccb994edb 100644
--- a/ext/ldap/ldap_arginfo.h
+++ b/ext/ldap/ldap_arginfo.h
@@ -475,7 +475,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(ldap_connect, arginfo_ldap_connect)
 #endif
 	ZEND_FE(ldap_unbind, arginfo_ldap_unbind)
-	ZEND_FALIAS(ldap_close, ldap_unbind, arginfo_ldap_close)
+	ZEND_RAW_FENTRY("ldap_close", zif_ldap_unbind, arginfo_ldap_close, 0, NULL, NULL)
 	ZEND_FE(ldap_bind, arginfo_ldap_bind)
 	ZEND_FE(ldap_bind_ext, arginfo_ldap_bind_ext)
 #if defined(HAVE_LDAP_SASL)
@@ -493,7 +493,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(ldap_next_attribute, arginfo_ldap_next_attribute)
 	ZEND_FE(ldap_get_attributes, arginfo_ldap_get_attributes)
 	ZEND_FE(ldap_get_values_len, arginfo_ldap_get_values_len)
-	ZEND_FALIAS(ldap_get_values, ldap_get_values_len, arginfo_ldap_get_values)
+	ZEND_RAW_FENTRY("ldap_get_values", zif_ldap_get_values_len, arginfo_ldap_get_values, 0, NULL, NULL)
 	ZEND_FE(ldap_get_dn, arginfo_ldap_get_dn)
 	ZEND_FE(ldap_explode_dn, arginfo_ldap_explode_dn)
 	ZEND_FE(ldap_dn2ufn, arginfo_ldap_dn2ufn)
@@ -505,7 +505,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(ldap_mod_add, arginfo_ldap_mod_add)
 	ZEND_FE(ldap_mod_add_ext, arginfo_ldap_mod_add_ext)
 	ZEND_FE(ldap_mod_replace, arginfo_ldap_mod_replace)
-	ZEND_FALIAS(ldap_modify, ldap_mod_replace, arginfo_ldap_modify)
+	ZEND_RAW_FENTRY("ldap_modify", zif_ldap_mod_replace, arginfo_ldap_modify, 0, NULL, NULL)
 	ZEND_FE(ldap_mod_replace_ext, arginfo_ldap_mod_replace_ext)
 	ZEND_FE(ldap_mod_del, arginfo_ldap_mod_del)
 	ZEND_FE(ldap_mod_del_ext, arginfo_ldap_mod_del_ext)
diff --git a/ext/libxml/libxml_arginfo.h b/ext/libxml/libxml_arginfo.h
index 5373b5ea003c0..8317a23dcfe19 100644
--- a/ext/libxml/libxml_arginfo.h
+++ b/ext/libxml/libxml_arginfo.h
@@ -44,7 +44,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(libxml_get_last_error, arginfo_libxml_get_last_error)
 	ZEND_FE(libxml_get_errors, arginfo_libxml_get_errors)
 	ZEND_FE(libxml_clear_errors, arginfo_libxml_clear_errors)
-	ZEND_DEP_FE(libxml_disable_entity_loader, arginfo_libxml_disable_entity_loader)
+	ZEND_RAW_FENTRY("libxml_disable_entity_loader", zif_libxml_disable_entity_loader, arginfo_libxml_disable_entity_loader, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(libxml_set_external_entity_loader, arginfo_libxml_set_external_entity_loader)
 	ZEND_FE(libxml_get_external_entity_loader, arginfo_libxml_get_external_entity_loader)
 	ZEND_FE_END
diff --git a/ext/mysqli/mysqli_arginfo.h b/ext/mysqli/mysqli_arginfo.h
index 80b79a04e338c..470c71b1c97f0 100644
--- a/ext/mysqli/mysqli_arginfo.h
+++ b/ext/mysqli/mysqli_arginfo.h
@@ -836,7 +836,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(mysqli_error, arginfo_mysqli_error)
 	ZEND_FE(mysqli_error_list, arginfo_mysqli_error_list)
 	ZEND_FE(mysqli_stmt_execute, arginfo_mysqli_stmt_execute)
-	ZEND_FALIAS(mysqli_execute, mysqli_stmt_execute, arginfo_mysqli_execute)
+	ZEND_RAW_FENTRY("mysqli_execute", zif_mysqli_stmt_execute, arginfo_mysqli_execute, 0, NULL, NULL)
 	ZEND_FE(mysqli_execute_query, arginfo_mysqli_execute_query)
 	ZEND_FE(mysqli_fetch_field, arginfo_mysqli_fetch_field)
 	ZEND_FE(mysqli_fetch_fields, arginfo_mysqli_fetch_fields)
@@ -873,7 +873,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(mysqli_num_fields, arginfo_mysqli_num_fields)
 	ZEND_FE(mysqli_num_rows, arginfo_mysqli_num_rows)
 	ZEND_FE(mysqli_options, arginfo_mysqli_options)
-	ZEND_FALIAS(mysqli_set_opt, mysqli_options, arginfo_mysqli_set_opt)
+	ZEND_RAW_FENTRY("mysqli_set_opt", zif_mysqli_options, arginfo_mysqli_set_opt, 0, NULL, NULL)
 	ZEND_FE(mysqli_ping, arginfo_mysqli_ping)
 	ZEND_FE(mysqli_poll, arginfo_mysqli_poll)
 	ZEND_FE(mysqli_prepare, arginfo_mysqli_prepare)
@@ -881,7 +881,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(mysqli_query, arginfo_mysqli_query)
 	ZEND_FE(mysqli_real_connect, arginfo_mysqli_real_connect)
 	ZEND_FE(mysqli_real_escape_string, arginfo_mysqli_real_escape_string)
-	ZEND_FALIAS(mysqli_escape_string, mysqli_real_escape_string, arginfo_mysqli_escape_string)
+	ZEND_RAW_FENTRY("mysqli_escape_string", zif_mysqli_real_escape_string, arginfo_mysqli_escape_string, 0, NULL, NULL)
 	ZEND_FE(mysqli_real_query, arginfo_mysqli_real_query)
 	ZEND_FE(mysqli_reap_async_query, arginfo_mysqli_reap_async_query)
 	ZEND_FE(mysqli_release_savepoint, arginfo_mysqli_release_savepoint)
@@ -934,93 +934,93 @@ static const zend_function_entry class_mysqli_driver_methods[] = {
 
 static const zend_function_entry class_mysqli_methods[] = {
 	ZEND_ME(mysqli, __construct, arginfo_class_mysqli___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(autocommit, mysqli_autocommit, arginfo_class_mysqli_autocommit, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(begin_transaction, mysqli_begin_transaction, arginfo_class_mysqli_begin_transaction, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(change_user, mysqli_change_user, arginfo_class_mysqli_change_user, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(character_set_name, mysqli_character_set_name, arginfo_class_mysqli_character_set_name, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(close, mysqli_close, arginfo_class_mysqli_close, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(commit, mysqli_commit, arginfo_class_mysqli_commit, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(connect, mysqli_connect, arginfo_class_mysqli_connect, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(dump_debug_info, mysqli_dump_debug_info, arginfo_class_mysqli_dump_debug_info, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(debug, mysqli_debug, arginfo_class_mysqli_debug, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_charset, mysqli_get_charset, arginfo_class_mysqli_get_charset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(execute_query, mysqli_execute_query, arginfo_class_mysqli_execute_query, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_client_info, mysqli_get_client_info, arginfo_class_mysqli_get_client_info, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
-	ZEND_ME_MAPPING(get_connection_stats, mysqli_get_connection_stats, arginfo_class_mysqli_get_connection_stats, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_server_info, mysqli_get_server_info, arginfo_class_mysqli_get_server_info, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_warnings, mysqli_get_warnings, arginfo_class_mysqli_get_warnings, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("autocommit", zif_mysqli_autocommit, arginfo_class_mysqli_autocommit, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("begin_transaction", zif_mysqli_begin_transaction, arginfo_class_mysqli_begin_transaction, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("change_user", zif_mysqli_change_user, arginfo_class_mysqli_change_user, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("character_set_name", zif_mysqli_character_set_name, arginfo_class_mysqli_character_set_name, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("close", zif_mysqli_close, arginfo_class_mysqli_close, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("commit", zif_mysqli_commit, arginfo_class_mysqli_commit, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("connect", zif_mysqli_connect, arginfo_class_mysqli_connect, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("dump_debug_info", zif_mysqli_dump_debug_info, arginfo_class_mysqli_dump_debug_info, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("debug", zif_mysqli_debug, arginfo_class_mysqli_debug, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_charset", zif_mysqli_get_charset, arginfo_class_mysqli_get_charset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("execute_query", zif_mysqli_execute_query, arginfo_class_mysqli_execute_query, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_client_info", zif_mysqli_get_client_info, arginfo_class_mysqli_get_client_info, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("get_connection_stats", zif_mysqli_get_connection_stats, arginfo_class_mysqli_get_connection_stats, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_server_info", zif_mysqli_get_server_info, arginfo_class_mysqli_get_server_info, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_warnings", zif_mysqli_get_warnings, arginfo_class_mysqli_get_warnings, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(mysqli, init, arginfo_class_mysqli_init, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
-	ZEND_ME_MAPPING(kill, mysqli_kill, arginfo_class_mysqli_kill, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(multi_query, mysqli_multi_query, arginfo_class_mysqli_multi_query, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(more_results, mysqli_more_results, arginfo_class_mysqli_more_results, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(next_result, mysqli_next_result, arginfo_class_mysqli_next_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(ping, mysqli_ping, arginfo_class_mysqli_ping, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(poll, mysqli_poll, arginfo_class_mysqli_poll, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(prepare, mysqli_prepare, arginfo_class_mysqli_prepare, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(query, mysqli_query, arginfo_class_mysqli_query, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(real_connect, mysqli_real_connect, arginfo_class_mysqli_real_connect, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(real_escape_string, mysqli_real_escape_string, arginfo_class_mysqli_real_escape_string, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(reap_async_query, mysqli_reap_async_query, arginfo_class_mysqli_reap_async_query, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(escape_string, mysqli_real_escape_string, arginfo_class_mysqli_escape_string, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(real_query, mysqli_real_query, arginfo_class_mysqli_real_query, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(release_savepoint, mysqli_release_savepoint, arginfo_class_mysqli_release_savepoint, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(rollback, mysqli_rollback, arginfo_class_mysqli_rollback, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(savepoint, mysqli_savepoint, arginfo_class_mysqli_savepoint, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(select_db, mysqli_select_db, arginfo_class_mysqli_select_db, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(set_charset, mysqli_set_charset, arginfo_class_mysqli_set_charset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(options, mysqli_options, arginfo_class_mysqli_options, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(set_opt, mysqli_options, arginfo_class_mysqli_set_opt, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(ssl_set, mysqli_ssl_set, arginfo_class_mysqli_ssl_set, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(stat, mysqli_stat, arginfo_class_mysqli_stat, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(stmt_init, mysqli_stmt_init, arginfo_class_mysqli_stmt_init, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(store_result, mysqli_store_result, arginfo_class_mysqli_store_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(thread_safe, mysqli_thread_safe, arginfo_class_mysqli_thread_safe, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(use_result, mysqli_use_result, arginfo_class_mysqli_use_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(refresh, mysqli_refresh, arginfo_class_mysqli_refresh, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("kill", zif_mysqli_kill, arginfo_class_mysqli_kill, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("multi_query", zif_mysqli_multi_query, arginfo_class_mysqli_multi_query, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("more_results", zif_mysqli_more_results, arginfo_class_mysqli_more_results, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("next_result", zif_mysqli_next_result, arginfo_class_mysqli_next_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("ping", zif_mysqli_ping, arginfo_class_mysqli_ping, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("poll", zif_mysqli_poll, arginfo_class_mysqli_poll, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("prepare", zif_mysqli_prepare, arginfo_class_mysqli_prepare, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("query", zif_mysqli_query, arginfo_class_mysqli_query, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("real_connect", zif_mysqli_real_connect, arginfo_class_mysqli_real_connect, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("real_escape_string", zif_mysqli_real_escape_string, arginfo_class_mysqli_real_escape_string, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("reap_async_query", zif_mysqli_reap_async_query, arginfo_class_mysqli_reap_async_query, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("escape_string", zif_mysqli_real_escape_string, arginfo_class_mysqli_escape_string, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("real_query", zif_mysqli_real_query, arginfo_class_mysqli_real_query, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("release_savepoint", zif_mysqli_release_savepoint, arginfo_class_mysqli_release_savepoint, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("rollback", zif_mysqli_rollback, arginfo_class_mysqli_rollback, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("savepoint", zif_mysqli_savepoint, arginfo_class_mysqli_savepoint, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("select_db", zif_mysqli_select_db, arginfo_class_mysqli_select_db, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("set_charset", zif_mysqli_set_charset, arginfo_class_mysqli_set_charset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("options", zif_mysqli_options, arginfo_class_mysqli_options, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("set_opt", zif_mysqli_options, arginfo_class_mysqli_set_opt, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("ssl_set", zif_mysqli_ssl_set, arginfo_class_mysqli_ssl_set, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("stat", zif_mysqli_stat, arginfo_class_mysqli_stat, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("stmt_init", zif_mysqli_stmt_init, arginfo_class_mysqli_stmt_init, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("store_result", zif_mysqli_store_result, arginfo_class_mysqli_store_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("thread_safe", zif_mysqli_thread_safe, arginfo_class_mysqli_thread_safe, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("use_result", zif_mysqli_use_result, arginfo_class_mysqli_use_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("refresh", zif_mysqli_refresh, arginfo_class_mysqli_refresh, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_mysqli_result_methods[] = {
 	ZEND_ME(mysqli_result, __construct, arginfo_class_mysqli_result___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(close, mysqli_free_result, arginfo_class_mysqli_result_close, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(free, mysqli_free_result, arginfo_class_mysqli_result_free, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(data_seek, mysqli_data_seek, arginfo_class_mysqli_result_data_seek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_field, mysqli_fetch_field, arginfo_class_mysqli_result_fetch_field, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_fields, mysqli_fetch_fields, arginfo_class_mysqli_result_fetch_fields, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_field_direct, mysqli_fetch_field_direct, arginfo_class_mysqli_result_fetch_field_direct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_all, mysqli_fetch_all, arginfo_class_mysqli_result_fetch_all, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_array, mysqli_fetch_array, arginfo_class_mysqli_result_fetch_array, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_assoc, mysqli_fetch_assoc, arginfo_class_mysqli_result_fetch_assoc, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_object, mysqli_fetch_object, arginfo_class_mysqli_result_fetch_object, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_row, mysqli_fetch_row, arginfo_class_mysqli_result_fetch_row, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch_column, mysqli_fetch_column, arginfo_class_mysqli_result_fetch_column, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(field_seek, mysqli_field_seek, arginfo_class_mysqli_result_field_seek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(free_result, mysqli_free_result, arginfo_class_mysqli_result_free_result, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("close", zif_mysqli_free_result, arginfo_class_mysqli_result_close, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("free", zif_mysqli_free_result, arginfo_class_mysqli_result_free, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("data_seek", zif_mysqli_data_seek, arginfo_class_mysqli_result_data_seek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_field", zif_mysqli_fetch_field, arginfo_class_mysqli_result_fetch_field, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_fields", zif_mysqli_fetch_fields, arginfo_class_mysqli_result_fetch_fields, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_field_direct", zif_mysqli_fetch_field_direct, arginfo_class_mysqli_result_fetch_field_direct, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_all", zif_mysqli_fetch_all, arginfo_class_mysqli_result_fetch_all, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_array", zif_mysqli_fetch_array, arginfo_class_mysqli_result_fetch_array, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_assoc", zif_mysqli_fetch_assoc, arginfo_class_mysqli_result_fetch_assoc, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_object", zif_mysqli_fetch_object, arginfo_class_mysqli_result_fetch_object, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_row", zif_mysqli_fetch_row, arginfo_class_mysqli_result_fetch_row, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch_column", zif_mysqli_fetch_column, arginfo_class_mysqli_result_fetch_column, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("field_seek", zif_mysqli_field_seek, arginfo_class_mysqli_result_field_seek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("free_result", zif_mysqli_free_result, arginfo_class_mysqli_result_free_result, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(mysqli_result, getIterator, arginfo_class_mysqli_result_getIterator, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_mysqli_stmt_methods[] = {
 	ZEND_ME(mysqli_stmt, __construct, arginfo_class_mysqli_stmt___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(attr_get, mysqli_stmt_attr_get, arginfo_class_mysqli_stmt_attr_get, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(attr_set, mysqli_stmt_attr_set, arginfo_class_mysqli_stmt_attr_set, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(bind_param, mysqli_stmt_bind_param, arginfo_class_mysqli_stmt_bind_param, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(bind_result, mysqli_stmt_bind_result, arginfo_class_mysqli_stmt_bind_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(close, mysqli_stmt_close, arginfo_class_mysqli_stmt_close, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(data_seek, mysqli_stmt_data_seek, arginfo_class_mysqli_stmt_data_seek, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(execute, mysqli_stmt_execute, arginfo_class_mysqli_stmt_execute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fetch, mysqli_stmt_fetch, arginfo_class_mysqli_stmt_fetch, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_warnings, mysqli_stmt_get_warnings, arginfo_class_mysqli_stmt_get_warnings, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(result_metadata, mysqli_stmt_result_metadata, arginfo_class_mysqli_stmt_result_metadata, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(more_results, mysqli_stmt_more_results, arginfo_class_mysqli_stmt_more_results, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(next_result, mysqli_stmt_next_result, arginfo_class_mysqli_stmt_next_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(num_rows, mysqli_stmt_num_rows, arginfo_class_mysqli_stmt_num_rows, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(send_long_data, mysqli_stmt_send_long_data, arginfo_class_mysqli_stmt_send_long_data, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(free_result, mysqli_stmt_free_result, arginfo_class_mysqli_stmt_free_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(reset, mysqli_stmt_reset, arginfo_class_mysqli_stmt_reset, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(prepare, mysqli_stmt_prepare, arginfo_class_mysqli_stmt_prepare, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(store_result, mysqli_stmt_store_result, arginfo_class_mysqli_stmt_store_result, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(get_result, mysqli_stmt_get_result, arginfo_class_mysqli_stmt_get_result, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("attr_get", zif_mysqli_stmt_attr_get, arginfo_class_mysqli_stmt_attr_get, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("attr_set", zif_mysqli_stmt_attr_set, arginfo_class_mysqli_stmt_attr_set, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("bind_param", zif_mysqli_stmt_bind_param, arginfo_class_mysqli_stmt_bind_param, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("bind_result", zif_mysqli_stmt_bind_result, arginfo_class_mysqli_stmt_bind_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("close", zif_mysqli_stmt_close, arginfo_class_mysqli_stmt_close, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("data_seek", zif_mysqli_stmt_data_seek, arginfo_class_mysqli_stmt_data_seek, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("execute", zif_mysqli_stmt_execute, arginfo_class_mysqli_stmt_execute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fetch", zif_mysqli_stmt_fetch, arginfo_class_mysqli_stmt_fetch, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_warnings", zif_mysqli_stmt_get_warnings, arginfo_class_mysqli_stmt_get_warnings, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("result_metadata", zif_mysqli_stmt_result_metadata, arginfo_class_mysqli_stmt_result_metadata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("more_results", zif_mysqli_stmt_more_results, arginfo_class_mysqli_stmt_more_results, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("next_result", zif_mysqli_stmt_next_result, arginfo_class_mysqli_stmt_next_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("num_rows", zif_mysqli_stmt_num_rows, arginfo_class_mysqli_stmt_num_rows, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("send_long_data", zif_mysqli_stmt_send_long_data, arginfo_class_mysqli_stmt_send_long_data, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("free_result", zif_mysqli_stmt_free_result, arginfo_class_mysqli_stmt_free_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("reset", zif_mysqli_stmt_reset, arginfo_class_mysqli_stmt_reset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("prepare", zif_mysqli_stmt_prepare, arginfo_class_mysqli_stmt_prepare, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("store_result", zif_mysqli_stmt_store_result, arginfo_class_mysqli_stmt_store_result, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("get_result", zif_mysqli_stmt_get_result, arginfo_class_mysqli_stmt_get_result, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/odbc/odbc_arginfo.h b/ext/odbc/odbc_arginfo.h
index 1c81dbc008ff5..481f1730f3991 100644
--- a/ext/odbc/odbc_arginfo.h
+++ b/ext/odbc/odbc_arginfo.h
@@ -331,7 +331,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(odbc_data_source, arginfo_odbc_data_source)
 #endif
 	ZEND_FE(odbc_exec, arginfo_odbc_exec)
-	ZEND_FALIAS(odbc_do, odbc_exec, arginfo_odbc_do)
+	ZEND_RAW_FENTRY("odbc_do", zif_odbc_exec, arginfo_odbc_do, 0, NULL, NULL)
 #if defined(PHP_ODBC_HAVE_FETCH_HASH)
 	ZEND_FE(odbc_fetch_object, arginfo_odbc_fetch_object)
 #endif
@@ -341,7 +341,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(odbc_fetch_into, arginfo_odbc_fetch_into)
 	ZEND_FE(odbc_fetch_row, arginfo_odbc_fetch_row)
 	ZEND_FE(odbc_result, arginfo_odbc_result)
-	ZEND_DEP_FE(odbc_result_all, arginfo_odbc_result_all)
+	ZEND_RAW_FENTRY("odbc_result_all", zif_odbc_result_all, arginfo_odbc_result_all, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(odbc_free_result, arginfo_odbc_free_result)
 	ZEND_FE(odbc_connect, arginfo_odbc_connect)
 	ZEND_FE(odbc_pconnect, arginfo_odbc_pconnect)
@@ -354,7 +354,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(odbc_field_name, arginfo_odbc_field_name)
 	ZEND_FE(odbc_field_type, arginfo_odbc_field_type)
 	ZEND_FE(odbc_field_len, arginfo_odbc_field_len)
-	ZEND_FALIAS(odbc_field_precision, odbc_field_len, arginfo_odbc_field_precision)
+	ZEND_RAW_FENTRY("odbc_field_precision", zif_odbc_field_len, arginfo_odbc_field_precision, 0, NULL, NULL)
 	ZEND_FE(odbc_field_scale, arginfo_odbc_field_scale)
 	ZEND_FE(odbc_field_num, arginfo_odbc_field_num)
 	ZEND_FE(odbc_autocommit, arginfo_odbc_autocommit)
diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 05a1fec2b637a..31fae17267159 100644
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -751,7 +751,7 @@ static void zend_file_cache_serialize_class(zval                     *zv,
 	}
 	zend_file_cache_serialize_hash(&ce->constants_table, script, info, buf, zend_file_cache_serialize_class_constant);
 	SERIALIZE_STR(ce->info.user.filename);
-	SERIALIZE_STR(ce->info.user.doc_comment);
+	SERIALIZE_STR(ce->doc_comment);
 	SERIALIZE_ATTRIBUTES(ce->attributes);
 	zend_file_cache_serialize_hash(&ce->properties_info, script, info, buf, zend_file_cache_serialize_prop_info);
 
@@ -1592,7 +1592,7 @@ static void zend_file_cache_unserialize_class(zval                    *zv,
 	zend_file_cache_unserialize_hash(&ce->constants_table,
 			script, buf, zend_file_cache_unserialize_class_constant, NULL);
 	UNSERIALIZE_STR(ce->info.user.filename);
-	UNSERIALIZE_STR(ce->info.user.doc_comment);
+	UNSERIALIZE_STR(ce->doc_comment);
 	UNSERIALIZE_ATTRIBUTES(ce->attributes);
 	zend_file_cache_unserialize_hash(&ce->properties_info,
 			script, buf, zend_file_cache_unserialize_prop_info, NULL);
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 0d9ad4b61884b..e13a38d16765b 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -982,15 +982,15 @@ zend_class_entry *zend_persist_class_entry(zend_class_entry *orig_ce)
 			zend_accel_store_string(ce->info.user.filename);
 		}
 
-		if (ce->info.user.doc_comment) {
+		if (ce->doc_comment) {
 			if (ZCG(accel_directives).save_comments) {
-				zend_accel_store_interned_string(ce->info.user.doc_comment);
+				zend_accel_store_interned_string(ce->doc_comment);
 			} else {
-				if (!zend_shared_alloc_get_xlat_entry(ce->info.user.doc_comment)) {
-					zend_shared_alloc_register_xlat_entry(ce->info.user.doc_comment, ce->info.user.doc_comment);
-					zend_string_release_ex(ce->info.user.doc_comment, 0);
+				if (!zend_shared_alloc_get_xlat_entry(ce->doc_comment)) {
+					zend_shared_alloc_register_xlat_entry(ce->doc_comment, ce->doc_comment);
+					zend_string_release_ex(ce->doc_comment, 0);
 				}
-				ce->info.user.doc_comment = NULL;
+				ce->doc_comment = NULL;
 			}
 		}
 
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 2d4a3c92afa29..c4c5c5fa3ba5f 100644
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -487,8 +487,8 @@ void zend_persist_class_entry_calc(zend_class_entry *ce)
 			ADD_STRING(ce->info.user.filename);
 		}
 
-		if (ZCG(accel_directives).save_comments && ce->info.user.doc_comment) {
-			ADD_STRING(ce->info.user.doc_comment);
+		if (ZCG(accel_directives).save_comments && ce->doc_comment) {
+			ADD_STRING(ce->doc_comment);
 		}
 
 		if (ce->attributes) {
diff --git a/ext/openssl/openssl_arginfo.h b/ext/openssl/openssl_arginfo.h
index 72d78abac919b..e48381624eb4e 100644
--- a/ext/openssl/openssl_arginfo.h
+++ b/ext/openssl/openssl_arginfo.h
@@ -461,7 +461,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(openssl_x509_parse, arginfo_openssl_x509_parse)
 	ZEND_FE(openssl_x509_checkpurpose, arginfo_openssl_x509_checkpurpose)
 	ZEND_FE(openssl_x509_read, arginfo_openssl_x509_read)
-	ZEND_DEP_FE(openssl_x509_free, arginfo_openssl_x509_free)
+	ZEND_RAW_FENTRY("openssl_x509_free", zif_openssl_x509_free, arginfo_openssl_x509_free, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(openssl_pkcs12_export_to_file, arginfo_openssl_pkcs12_export_to_file)
 	ZEND_FE(openssl_pkcs12_export, arginfo_openssl_pkcs12_export)
 	ZEND_FE(openssl_pkcs12_read, arginfo_openssl_pkcs12_read)
@@ -475,11 +475,11 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(openssl_pkey_export_to_file, arginfo_openssl_pkey_export_to_file)
 	ZEND_FE(openssl_pkey_export, arginfo_openssl_pkey_export)
 	ZEND_FE(openssl_pkey_get_public, arginfo_openssl_pkey_get_public)
-	ZEND_FALIAS(openssl_get_publickey, openssl_pkey_get_public, arginfo_openssl_get_publickey)
-	ZEND_DEP_FE(openssl_pkey_free, arginfo_openssl_pkey_free)
-	ZEND_DEP_FALIAS(openssl_free_key, openssl_pkey_free, arginfo_openssl_free_key)
+	ZEND_RAW_FENTRY("openssl_get_publickey", zif_openssl_pkey_get_public, arginfo_openssl_get_publickey, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("openssl_pkey_free", zif_openssl_pkey_free, arginfo_openssl_pkey_free, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("openssl_free_key", zif_openssl_pkey_free, arginfo_openssl_free_key, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(openssl_pkey_get_private, arginfo_openssl_pkey_get_private)
-	ZEND_FALIAS(openssl_get_privatekey, openssl_pkey_get_private, arginfo_openssl_get_privatekey)
+	ZEND_RAW_FENTRY("openssl_get_privatekey", zif_openssl_pkey_get_private, arginfo_openssl_get_privatekey, 0, NULL, NULL)
 	ZEND_FE(openssl_pkey_get_details, arginfo_openssl_pkey_get_details)
 	ZEND_FE(openssl_pbkdf2, arginfo_openssl_pbkdf2)
 	ZEND_FE(openssl_pkcs7_verify, arginfo_openssl_pkcs7_verify)
diff --git a/ext/pcntl/pcntl_arginfo.h b/ext/pcntl/pcntl_arginfo.h
index 3f935866b9938..8cb96afee8d7f 100644
--- a/ext/pcntl/pcntl_arginfo.h
+++ b/ext/pcntl/pcntl_arginfo.h
@@ -205,7 +205,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(pcntl_exec, arginfo_pcntl_exec)
 	ZEND_FE(pcntl_alarm, arginfo_pcntl_alarm)
 	ZEND_FE(pcntl_get_last_error, arginfo_pcntl_get_last_error)
-	ZEND_FALIAS(pcntl_errno, pcntl_get_last_error, arginfo_pcntl_errno)
+	ZEND_RAW_FENTRY("pcntl_errno", zif_pcntl_get_last_error, arginfo_pcntl_errno, 0, NULL, NULL)
 #if defined(HAVE_GETPRIORITY)
 	ZEND_FE(pcntl_getpriority, arginfo_pcntl_getpriority)
 #endif
diff --git a/ext/pcre/php_pcre_arginfo.h b/ext/pcre/php_pcre_arginfo.h
index 9ec00d1a39aef..86eaf0d8d60f3 100644
--- a/ext/pcre/php_pcre_arginfo.h
+++ b/ext/pcre/php_pcre_arginfo.h
@@ -88,14 +88,14 @@ ZEND_FUNCTION(preg_last_error);
 ZEND_FUNCTION(preg_last_error_msg);
 
 static const zend_function_entry ext_functions[] = {
-	ZEND_FRAMELESS_FE(preg_match, arginfo_preg_match, 0, frameless_function_infos_preg_match)
+	ZEND_RAW_FENTRY("preg_match", zif_preg_match, arginfo_preg_match, 0, frameless_function_infos_preg_match, NULL)
 	ZEND_FE(preg_match_all, arginfo_preg_match_all)
-	ZEND_FRAMELESS_FE(preg_replace, arginfo_preg_replace, 0, frameless_function_infos_preg_replace)
+	ZEND_RAW_FENTRY("preg_replace", zif_preg_replace, arginfo_preg_replace, 0, frameless_function_infos_preg_replace, NULL)
 	ZEND_FE(preg_filter, arginfo_preg_filter)
 	ZEND_FE(preg_replace_callback, arginfo_preg_replace_callback)
 	ZEND_FE(preg_replace_callback_array, arginfo_preg_replace_callback_array)
 	ZEND_FE(preg_split, arginfo_preg_split)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(preg_quote, arginfo_preg_quote)
+	ZEND_RAW_FENTRY("preg_quote", zif_preg_quote, arginfo_preg_quote, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(preg_grep, arginfo_preg_grep)
 	ZEND_FE(preg_last_error, arginfo_preg_last_error)
 	ZEND_FE(preg_last_error_msg, arginfo_preg_last_error_msg)
diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 43121dc9b5c6f..48c3f00340a7b 100644
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -1336,6 +1336,7 @@ bool pdo_hash_methods(pdo_dbh_object_t *dbh_obj, int kind)
 		} else {
 			func.fn_flags = ZEND_ACC_PUBLIC | ZEND_ACC_NEVER_CACHE;
 		}
+		func.doc_comment = NULL;
 		if (funcs->arg_info) {
 			zend_internal_function_info *info = (zend_internal_function_info*)funcs->arg_info;
 
diff --git a/ext/pgsql/pgsql_arginfo.h b/ext/pgsql/pgsql_arginfo.h
index a65a880814c36..169f0eff67bbf 100644
--- a/ext/pgsql/pgsql_arginfo.h
+++ b/ext/pgsql/pgsql_arginfo.h
@@ -561,7 +561,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(pg_close, arginfo_pg_close)
 	ZEND_FE(pg_dbname, arginfo_pg_dbname)
 	ZEND_FE(pg_last_error, arginfo_pg_last_error)
-	ZEND_DEP_FALIAS(pg_errormessage, pg_last_error, arginfo_pg_errormessage)
+	ZEND_RAW_FENTRY("pg_errormessage", zif_pg_last_error, arginfo_pg_errormessage, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_options, arginfo_pg_options)
 	ZEND_FE(pg_port, arginfo_pg_port)
 	ZEND_FE(pg_tty, arginfo_pg_tty)
@@ -570,29 +570,29 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(pg_parameter_status, arginfo_pg_parameter_status)
 	ZEND_FE(pg_ping, arginfo_pg_ping)
 	ZEND_FE(pg_query, arginfo_pg_query)
-	ZEND_FALIAS(pg_exec, pg_query, arginfo_pg_exec)
+	ZEND_RAW_FENTRY("pg_exec", zif_pg_query, arginfo_pg_exec, 0, NULL, NULL)
 	ZEND_FE(pg_query_params, arginfo_pg_query_params)
 	ZEND_FE(pg_prepare, arginfo_pg_prepare)
 	ZEND_FE(pg_execute, arginfo_pg_execute)
 	ZEND_FE(pg_num_rows, arginfo_pg_num_rows)
-	ZEND_DEP_FALIAS(pg_numrows, pg_num_rows, arginfo_pg_numrows)
+	ZEND_RAW_FENTRY("pg_numrows", zif_pg_num_rows, arginfo_pg_numrows, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_num_fields, arginfo_pg_num_fields)
-	ZEND_DEP_FALIAS(pg_numfields, pg_num_fields, arginfo_pg_numfields)
+	ZEND_RAW_FENTRY("pg_numfields", zif_pg_num_fields, arginfo_pg_numfields, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_affected_rows, arginfo_pg_affected_rows)
-	ZEND_DEP_FALIAS(pg_cmdtuples, pg_affected_rows, arginfo_pg_cmdtuples)
+	ZEND_RAW_FENTRY("pg_cmdtuples", zif_pg_affected_rows, arginfo_pg_cmdtuples, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_last_notice, arginfo_pg_last_notice)
 	ZEND_FE(pg_field_table, arginfo_pg_field_table)
 	ZEND_FE(pg_field_name, arginfo_pg_field_name)
-	ZEND_DEP_FALIAS(pg_fieldname, pg_field_name, arginfo_pg_fieldname)
+	ZEND_RAW_FENTRY("pg_fieldname", zif_pg_field_name, arginfo_pg_fieldname, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_field_size, arginfo_pg_field_size)
-	ZEND_DEP_FALIAS(pg_fieldsize, pg_field_size, arginfo_pg_fieldsize)
+	ZEND_RAW_FENTRY("pg_fieldsize", zif_pg_field_size, arginfo_pg_fieldsize, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_field_type, arginfo_pg_field_type)
-	ZEND_DEP_FALIAS(pg_fieldtype, pg_field_type, arginfo_pg_fieldtype)
+	ZEND_RAW_FENTRY("pg_fieldtype", zif_pg_field_type, arginfo_pg_fieldtype, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_field_type_oid, arginfo_pg_field_type_oid)
 	ZEND_FE(pg_field_num, arginfo_pg_field_num)
-	ZEND_DEP_FALIAS(pg_fieldnum, pg_field_num, arginfo_pg_fieldnum)
+	ZEND_RAW_FENTRY("pg_fieldnum", zif_pg_field_num, arginfo_pg_fieldnum, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_fetch_result, arginfo_pg_fetch_result)
-	ZEND_DEP_FALIAS(pg_result, pg_fetch_result, arginfo_pg_result)
+	ZEND_RAW_FENTRY("pg_result", zif_pg_fetch_result, arginfo_pg_result, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_fetch_row, arginfo_pg_fetch_row)
 	ZEND_FE(pg_fetch_assoc, arginfo_pg_fetch_assoc)
 	ZEND_FE(pg_fetch_array, arginfo_pg_fetch_array)
@@ -601,41 +601,41 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(pg_fetch_all_columns, arginfo_pg_fetch_all_columns)
 	ZEND_FE(pg_result_seek, arginfo_pg_result_seek)
 	ZEND_FE(pg_field_prtlen, arginfo_pg_field_prtlen)
-	ZEND_DEP_FE(pg_fieldprtlen, arginfo_pg_fieldprtlen)
+	ZEND_RAW_FENTRY("pg_fieldprtlen", zif_pg_fieldprtlen, arginfo_pg_fieldprtlen, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_field_is_null, arginfo_pg_field_is_null)
-	ZEND_DEP_FE(pg_fieldisnull, arginfo_pg_fieldisnull)
+	ZEND_RAW_FENTRY("pg_fieldisnull", zif_pg_fieldisnull, arginfo_pg_fieldisnull, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_free_result, arginfo_pg_free_result)
-	ZEND_DEP_FALIAS(pg_freeresult, pg_free_result, arginfo_pg_freeresult)
+	ZEND_RAW_FENTRY("pg_freeresult", zif_pg_free_result, arginfo_pg_freeresult, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_last_oid, arginfo_pg_last_oid)
-	ZEND_DEP_FALIAS(pg_getlastoid, pg_last_oid, arginfo_pg_getlastoid)
+	ZEND_RAW_FENTRY("pg_getlastoid", zif_pg_last_oid, arginfo_pg_getlastoid, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_trace, arginfo_pg_trace)
 	ZEND_FE(pg_untrace, arginfo_pg_untrace)
 	ZEND_FE(pg_lo_create, arginfo_pg_lo_create)
-	ZEND_DEP_FALIAS(pg_locreate, pg_lo_create, arginfo_pg_locreate)
+	ZEND_RAW_FENTRY("pg_locreate", zif_pg_lo_create, arginfo_pg_locreate, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_unlink, arginfo_pg_lo_unlink)
-	ZEND_DEP_FALIAS(pg_lounlink, pg_lo_unlink, arginfo_pg_lounlink)
+	ZEND_RAW_FENTRY("pg_lounlink", zif_pg_lo_unlink, arginfo_pg_lounlink, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_open, arginfo_pg_lo_open)
-	ZEND_DEP_FALIAS(pg_loopen, pg_lo_open, arginfo_pg_loopen)
+	ZEND_RAW_FENTRY("pg_loopen", zif_pg_lo_open, arginfo_pg_loopen, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_close, arginfo_pg_lo_close)
-	ZEND_DEP_FALIAS(pg_loclose, pg_lo_close, arginfo_pg_loclose)
+	ZEND_RAW_FENTRY("pg_loclose", zif_pg_lo_close, arginfo_pg_loclose, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_read, arginfo_pg_lo_read)
-	ZEND_DEP_FALIAS(pg_loread, pg_lo_read, arginfo_pg_loread)
+	ZEND_RAW_FENTRY("pg_loread", zif_pg_lo_read, arginfo_pg_loread, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_write, arginfo_pg_lo_write)
-	ZEND_DEP_FALIAS(pg_lowrite, pg_lo_write, arginfo_pg_lowrite)
+	ZEND_RAW_FENTRY("pg_lowrite", zif_pg_lo_write, arginfo_pg_lowrite, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_read_all, arginfo_pg_lo_read_all)
-	ZEND_DEP_FALIAS(pg_loreadall, pg_lo_read_all, arginfo_pg_loreadall)
+	ZEND_RAW_FENTRY("pg_loreadall", zif_pg_lo_read_all, arginfo_pg_loreadall, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_import, arginfo_pg_lo_import)
-	ZEND_DEP_FALIAS(pg_loimport, pg_lo_import, arginfo_pg_loimport)
+	ZEND_RAW_FENTRY("pg_loimport", zif_pg_lo_import, arginfo_pg_loimport, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_export, arginfo_pg_lo_export)
-	ZEND_DEP_FALIAS(pg_loexport, pg_lo_export, arginfo_pg_loexport)
+	ZEND_RAW_FENTRY("pg_loexport", zif_pg_lo_export, arginfo_pg_loexport, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_lo_seek, arginfo_pg_lo_seek)
 	ZEND_FE(pg_lo_tell, arginfo_pg_lo_tell)
 	ZEND_FE(pg_lo_truncate, arginfo_pg_lo_truncate)
 	ZEND_FE(pg_set_error_verbosity, arginfo_pg_set_error_verbosity)
 	ZEND_FE(pg_set_client_encoding, arginfo_pg_set_client_encoding)
-	ZEND_DEP_FALIAS(pg_setclientencoding, pg_set_client_encoding, arginfo_pg_setclientencoding)
+	ZEND_RAW_FENTRY("pg_setclientencoding", zif_pg_set_client_encoding, arginfo_pg_setclientencoding, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_client_encoding, arginfo_pg_client_encoding)
-	ZEND_DEP_FALIAS(pg_clientencoding, pg_client_encoding, arginfo_pg_clientencoding)
+	ZEND_RAW_FENTRY("pg_clientencoding", zif_pg_client_encoding, arginfo_pg_clientencoding, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(pg_end_copy, arginfo_pg_end_copy)
 	ZEND_FE(pg_put_line, arginfo_pg_put_line)
 	ZEND_FE(pg_copy_to, arginfo_pg_copy_to)
diff --git a/ext/phar/phar_object_arginfo.h b/ext/phar/phar_object_arginfo.h
index 7598d72844e0a..fc149ba0ac693 100644
--- a/ext/phar/phar_object_arginfo.h
+++ b/ext/phar/phar_object_arginfo.h
@@ -521,62 +521,62 @@ static const zend_function_entry class_Phar_methods[] = {
 };
 
 static const zend_function_entry class_PharData_methods[] = {
-	ZEND_MALIAS(Phar, __construct, __construct, arginfo_class_PharData___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, __destruct, __destruct, arginfo_class_PharData___destruct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, addEmptyDir, addEmptyDir, arginfo_class_PharData_addEmptyDir, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, addFile, addFile, arginfo_class_PharData_addFile, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, addFromString, addFromString, arginfo_class_PharData_addFromString, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, buildFromDirectory, buildFromDirectory, arginfo_class_PharData_buildFromDirectory, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, buildFromIterator, buildFromIterator, arginfo_class_PharData_buildFromIterator, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, compressFiles, compressFiles, arginfo_class_PharData_compressFiles, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, decompressFiles, decompressFiles, arginfo_class_PharData_decompressFiles, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, compress, compress, arginfo_class_PharData_compress, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, decompress, decompress, arginfo_class_PharData_decompress, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, convertToExecutable, convertToExecutable, arginfo_class_PharData_convertToExecutable, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, convertToData, convertToData, arginfo_class_PharData_convertToData, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, copy, copy, arginfo_class_PharData_copy, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, count, count, arginfo_class_PharData_count, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, delete, delete, arginfo_class_PharData_delete, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, delMetadata, delMetadata, arginfo_class_PharData_delMetadata, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, extractTo, extractTo, arginfo_class_PharData_extractTo, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getAlias, getAlias, arginfo_class_PharData_getAlias, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getPath, getPath, arginfo_class_PharData_getPath, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getMetadata, getMetadata, arginfo_class_PharData_getMetadata, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getModified, getModified, arginfo_class_PharData_getModified, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getSignature, getSignature, arginfo_class_PharData_getSignature, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getStub, getStub, arginfo_class_PharData_getStub, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, getVersion, getVersion, arginfo_class_PharData_getVersion, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, hasMetadata, hasMetadata, arginfo_class_PharData_hasMetadata, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, isBuffering, isBuffering, arginfo_class_PharData_isBuffering, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, isCompressed, isCompressed, arginfo_class_PharData_isCompressed, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, isFileFormat, isFileFormat, arginfo_class_PharData_isFileFormat, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, isWritable, isWritable, arginfo_class_PharData_isWritable, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, offsetExists, offsetExists, arginfo_class_PharData_offsetExists, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, offsetGet, offsetGet, arginfo_class_PharData_offsetGet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, offsetSet, offsetSet, arginfo_class_PharData_offsetSet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, offsetUnset, offsetUnset, arginfo_class_PharData_offsetUnset, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, setAlias, setAlias, arginfo_class_PharData_setAlias, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, setDefaultStub, setDefaultStub, arginfo_class_PharData_setDefaultStub, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, setMetadata, setMetadata, arginfo_class_PharData_setMetadata, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, setSignatureAlgorithm, setSignatureAlgorithm, arginfo_class_PharData_setSignatureAlgorithm, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, setStub, setStub, arginfo_class_PharData_setStub, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, startBuffering, startBuffering, arginfo_class_PharData_startBuffering, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, stopBuffering, stopBuffering, arginfo_class_PharData_stopBuffering, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Phar, apiVersion, apiVersion, arginfo_class_PharData_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, canCompress, canCompress, arginfo_class_PharData_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, canWrite, canWrite, arginfo_class_PharData_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, createDefaultStub, createDefaultStub, arginfo_class_PharData_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, getSupportedCompression, getSupportedCompression, arginfo_class_PharData_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, getSupportedSignatures, getSupportedSignatures, arginfo_class_PharData_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, interceptFileFuncs, interceptFileFuncs, arginfo_class_PharData_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, isValidPharFilename, isValidPharFilename, arginfo_class_PharData_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, loadPhar, loadPhar, arginfo_class_PharData_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, mapPhar, mapPhar, arginfo_class_PharData_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, running, running, arginfo_class_PharData_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, mount, mount, arginfo_class_PharData_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, mungServer, mungServer, arginfo_class_PharData_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, unlinkArchive, unlinkArchive, arginfo_class_PharData_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
-	ZEND_MALIAS(Phar, webPhar, webPhar, arginfo_class_PharData_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
+	ZEND_RAW_FENTRY("__construct", zim_Phar___construct, arginfo_class_PharData___construct, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__destruct", zim_Phar___destruct, arginfo_class_PharData___destruct, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("addEmptyDir", zim_Phar_addEmptyDir, arginfo_class_PharData_addEmptyDir, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("addFile", zim_Phar_addFile, arginfo_class_PharData_addFile, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("addFromString", zim_Phar_addFromString, arginfo_class_PharData_addFromString, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("buildFromDirectory", zim_Phar_buildFromDirectory, arginfo_class_PharData_buildFromDirectory, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("buildFromIterator", zim_Phar_buildFromIterator, arginfo_class_PharData_buildFromIterator, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("compressFiles", zim_Phar_compressFiles, arginfo_class_PharData_compressFiles, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("decompressFiles", zim_Phar_decompressFiles, arginfo_class_PharData_decompressFiles, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("compress", zim_Phar_compress, arginfo_class_PharData_compress, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("decompress", zim_Phar_decompress, arginfo_class_PharData_decompress, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("convertToExecutable", zim_Phar_convertToExecutable, arginfo_class_PharData_convertToExecutable, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("convertToData", zim_Phar_convertToData, arginfo_class_PharData_convertToData, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("copy", zim_Phar_copy, arginfo_class_PharData_copy, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("count", zim_Phar_count, arginfo_class_PharData_count, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("delete", zim_Phar_delete, arginfo_class_PharData_delete, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("delMetadata", zim_Phar_delMetadata, arginfo_class_PharData_delMetadata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("extractTo", zim_Phar_extractTo, arginfo_class_PharData_extractTo, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getAlias", zim_Phar_getAlias, arginfo_class_PharData_getAlias, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getPath", zim_Phar_getPath, arginfo_class_PharData_getPath, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getMetadata", zim_Phar_getMetadata, arginfo_class_PharData_getMetadata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getModified", zim_Phar_getModified, arginfo_class_PharData_getModified, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getSignature", zim_Phar_getSignature, arginfo_class_PharData_getSignature, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getStub", zim_Phar_getStub, arginfo_class_PharData_getStub, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getVersion", zim_Phar_getVersion, arginfo_class_PharData_getVersion, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("hasMetadata", zim_Phar_hasMetadata, arginfo_class_PharData_hasMetadata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isBuffering", zim_Phar_isBuffering, arginfo_class_PharData_isBuffering, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isCompressed", zim_Phar_isCompressed, arginfo_class_PharData_isCompressed, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isFileFormat", zim_Phar_isFileFormat, arginfo_class_PharData_isFileFormat, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isWritable", zim_Phar_isWritable, arginfo_class_PharData_isWritable, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetExists", zim_Phar_offsetExists, arginfo_class_PharData_offsetExists, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetGet", zim_Phar_offsetGet, arginfo_class_PharData_offsetGet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetSet", zim_Phar_offsetSet, arginfo_class_PharData_offsetSet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetUnset", zim_Phar_offsetUnset, arginfo_class_PharData_offsetUnset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setAlias", zim_Phar_setAlias, arginfo_class_PharData_setAlias, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setDefaultStub", zim_Phar_setDefaultStub, arginfo_class_PharData_setDefaultStub, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setMetadata", zim_Phar_setMetadata, arginfo_class_PharData_setMetadata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setSignatureAlgorithm", zim_Phar_setSignatureAlgorithm, arginfo_class_PharData_setSignatureAlgorithm, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setStub", zim_Phar_setStub, arginfo_class_PharData_setStub, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startBuffering", zim_Phar_startBuffering, arginfo_class_PharData_startBuffering, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("stopBuffering", zim_Phar_stopBuffering, arginfo_class_PharData_stopBuffering, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("apiVersion", zim_Phar_apiVersion, arginfo_class_PharData_apiVersion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("canCompress", zim_Phar_canCompress, arginfo_class_PharData_canCompress, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("canWrite", zim_Phar_canWrite, arginfo_class_PharData_canWrite, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("createDefaultStub", zim_Phar_createDefaultStub, arginfo_class_PharData_createDefaultStub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getSupportedCompression", zim_Phar_getSupportedCompression, arginfo_class_PharData_getSupportedCompression, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("getSupportedSignatures", zim_Phar_getSupportedSignatures, arginfo_class_PharData_getSupportedSignatures, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("interceptFileFuncs", zim_Phar_interceptFileFuncs, arginfo_class_PharData_interceptFileFuncs, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("isValidPharFilename", zim_Phar_isValidPharFilename, arginfo_class_PharData_isValidPharFilename, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("loadPhar", zim_Phar_loadPhar, arginfo_class_PharData_loadPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("mapPhar", zim_Phar_mapPhar, arginfo_class_PharData_mapPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("running", zim_Phar_running, arginfo_class_PharData_running, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("mount", zim_Phar_mount, arginfo_class_PharData_mount, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("mungServer", zim_Phar_mungServer, arginfo_class_PharData_mungServer, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("unlinkArchive", zim_Phar_unlinkArchive, arginfo_class_PharData_unlinkArchive, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
+	ZEND_RAW_FENTRY("webPhar", zim_Phar_webPhar, arginfo_class_PharData_webPhar, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/posix/posix_arginfo.h b/ext/posix/posix_arginfo.h
index 8aa5c88b9fa1e..664d822db9eda 100644
--- a/ext/posix/posix_arginfo.h
+++ b/ext/posix/posix_arginfo.h
@@ -320,7 +320,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(posix_setrlimit, arginfo_posix_setrlimit)
 #endif
 	ZEND_FE(posix_get_last_error, arginfo_posix_get_last_error)
-	ZEND_FALIAS(posix_errno, posix_get_last_error, arginfo_posix_errno)
+	ZEND_RAW_FENTRY("posix_errno", zif_posix_get_last_error, arginfo_posix_errno, 0, NULL, NULL)
 	ZEND_FE(posix_strerror, arginfo_posix_strerror)
 #if defined(HAVE_INITGROUPS)
 	ZEND_FE(posix_initgroups, arginfo_posix_initgroups)
diff --git a/ext/random/random_arginfo.h b/ext/random/random_arginfo.h
index 503b300dbefb8..82df476ed125a 100644
--- a/ext/random/random_arginfo.h
+++ b/ext/random/random_arginfo.h
@@ -157,11 +157,11 @@ ZEND_METHOD(Random_Randomizer, __unserialize);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(lcg_value, arginfo_lcg_value)
 	ZEND_FE(mt_srand, arginfo_mt_srand)
-	ZEND_FALIAS(srand, mt_srand, arginfo_srand)
+	ZEND_RAW_FENTRY("srand", zif_mt_srand, arginfo_srand, 0, NULL, NULL)
 	ZEND_FE(rand, arginfo_rand)
 	ZEND_FE(mt_rand, arginfo_mt_rand)
 	ZEND_FE(mt_getrandmax, arginfo_mt_getrandmax)
-	ZEND_FALIAS(getrandmax, mt_getrandmax, arginfo_getrandmax)
+	ZEND_RAW_FENTRY("getrandmax", zif_mt_getrandmax, arginfo_getrandmax, 0, NULL, NULL)
 	ZEND_FE(random_bytes, arginfo_random_bytes)
 	ZEND_FE(random_int, arginfo_random_int)
 	ZEND_FE_END
@@ -178,32 +178,32 @@ static const zend_function_entry class_Random_Engine_Mt19937_methods[] = {
 
 static const zend_function_entry class_Random_Engine_PcgOneseq128XslRr64_methods[] = {
 	ZEND_ME(Random_Engine_PcgOneseq128XslRr64, __construct, arginfo_class_Random_Engine_PcgOneseq128XslRr64___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, generate, generate, arginfo_class_Random_Engine_PcgOneseq128XslRr64_generate, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("generate", zim_Random_Engine_Mt19937_generate, arginfo_class_Random_Engine_PcgOneseq128XslRr64_generate, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(Random_Engine_PcgOneseq128XslRr64, jump, arginfo_class_Random_Engine_PcgOneseq128XslRr64_jump, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __serialize, __serialize, arginfo_class_Random_Engine_PcgOneseq128XslRr64___serialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __unserialize, __unserialize, arginfo_class_Random_Engine_PcgOneseq128XslRr64___unserialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __debugInfo, __debugInfo, arginfo_class_Random_Engine_PcgOneseq128XslRr64___debugInfo, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__serialize", zim_Random_Engine_Mt19937___serialize, arginfo_class_Random_Engine_PcgOneseq128XslRr64___serialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__unserialize", zim_Random_Engine_Mt19937___unserialize, arginfo_class_Random_Engine_PcgOneseq128XslRr64___unserialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__debugInfo", zim_Random_Engine_Mt19937___debugInfo, arginfo_class_Random_Engine_PcgOneseq128XslRr64___debugInfo, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Random_Engine_Xoshiro256StarStar_methods[] = {
 	ZEND_ME(Random_Engine_Xoshiro256StarStar, __construct, arginfo_class_Random_Engine_Xoshiro256StarStar___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, generate, generate, arginfo_class_Random_Engine_Xoshiro256StarStar_generate, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("generate", zim_Random_Engine_Mt19937_generate, arginfo_class_Random_Engine_Xoshiro256StarStar_generate, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(Random_Engine_Xoshiro256StarStar, jump, arginfo_class_Random_Engine_Xoshiro256StarStar_jump, ZEND_ACC_PUBLIC)
 	ZEND_ME(Random_Engine_Xoshiro256StarStar, jumpLong, arginfo_class_Random_Engine_Xoshiro256StarStar_jumpLong, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __serialize, __serialize, arginfo_class_Random_Engine_Xoshiro256StarStar___serialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __unserialize, __unserialize, arginfo_class_Random_Engine_Xoshiro256StarStar___unserialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(Random_Engine_Mt19937, __debugInfo, __debugInfo, arginfo_class_Random_Engine_Xoshiro256StarStar___debugInfo, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__serialize", zim_Random_Engine_Mt19937___serialize, arginfo_class_Random_Engine_Xoshiro256StarStar___serialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__unserialize", zim_Random_Engine_Mt19937___unserialize, arginfo_class_Random_Engine_Xoshiro256StarStar___unserialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__debugInfo", zim_Random_Engine_Mt19937___debugInfo, arginfo_class_Random_Engine_Xoshiro256StarStar___debugInfo, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Random_Engine_Secure_methods[] = {
-	ZEND_MALIAS(Random_Engine_Mt19937, generate, generate, arginfo_class_Random_Engine_Secure_generate, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("generate", zim_Random_Engine_Mt19937_generate, arginfo_class_Random_Engine_Secure_generate, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_Random_Engine_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(Random_Engine, generate, arginfo_class_Random_Engine_generate, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("generate", NULL, arginfo_class_Random_Engine_generate, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 10eaaa9734833..28a897ba89fce 100644
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -309,8 +309,8 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char
 	zend_string *sub_indent = strpprintf(0, "%s    ", indent);
 
 	/* TBD: Repair indenting of doc comment (or is this to be done in the parser?) */
-	if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
-		smart_str_append_printf(str, "%s%s", indent, ZSTR_VAL(ce->info.user.doc_comment));
+	if (ce->doc_comment) {
+		smart_str_append_printf(str, "%s%s", indent, ZSTR_VAL(ce->doc_comment));
 		smart_str_appendc(str, '\n');
 	}
 
@@ -566,6 +566,10 @@ static void _class_const_string(smart_str *str, zend_string *name, zend_class_co
 	const char *final = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_FINAL ? "final " : "";
 	zend_string *type_str = ZEND_TYPE_IS_SET(c->type) ? zend_type_to_string(c->type) : NULL;
 	const char *type = type_str ? ZSTR_VAL(type_str) : zend_zval_type_name(&c->value);
+
+	if (c->doc_comment) {
+		smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(c->doc_comment));
+	}
 	smart_str_append_printf(str, "%sConstant [ %s%s %s %s ] { ",
 		indent, final, visibility, type, ZSTR_VAL(name));
 	if (Z_TYPE(c->value) == IS_ARRAY) {
@@ -780,6 +784,8 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent
 	 */
 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
 		smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(fptr->op_array.doc_comment));
+	} else if (fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.doc_comment) {
+		smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(fptr->internal_function.doc_comment));
 	}
 
 	smart_str_appendl(str, indent, strlen(indent));
@@ -889,6 +895,9 @@ static zval *property_get_default(zend_property_info *prop_info) {
 /* {{{ _property_string */
 static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent)
 {
+	if (prop && prop->doc_comment) {
+		smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(prop->doc_comment));
+	}
 	smart_str_append_printf(str, "%sProperty [ ", indent);
 	if (!prop) {
 		smart_str_append_printf(str, "<dynamic> public $%s", prop_name);
@@ -1915,10 +1924,17 @@ ZEND_METHOD(ReflectionFunctionAbstract, getDocComment)
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_THROWS();
 	}
+
 	GET_REFLECTION_OBJECT_PTR(fptr);
+
 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
 		RETURN_STR_COPY(fptr->op_array.doc_comment);
 	}
+
+	if (fptr->type == ZEND_INTERNAL_FUNCTION && ((zend_internal_function *) fptr)->doc_comment) {
+		RETURN_STR_COPY(((zend_internal_function *) fptr)->doc_comment);
+	}
+
 	RETURN_FALSE;
 }
 /* }}} */
@@ -4396,8 +4412,8 @@ ZEND_METHOD(ReflectionClass, getDocComment)
 		RETURN_THROWS();
 	}
 	GET_REFLECTION_OBJECT_PTR(ce);
-	if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
-		RETURN_STR_COPY(ce->info.user.doc_comment);
+	if (ce->doc_comment) {
+		RETURN_STR_COPY(ce->doc_comment);
 	}
 	RETURN_FALSE;
 }
diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h
index 0459a531dd614..eaab1e8a786d5 100644
--- a/ext/reflection/php_reflection_arginfo.h
+++ b/ext/reflection/php_reflection_arginfo.h
@@ -860,7 +860,7 @@ static const zend_function_entry class_Reflector_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionFunctionAbstract_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionFunctionAbstract___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionFunctionAbstract___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionFunctionAbstract, inNamespace, arginfo_class_ReflectionFunctionAbstract_inNamespace, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionFunctionAbstract, isClosure, arginfo_class_ReflectionFunctionAbstract_isClosure, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionFunctionAbstract, isDeprecated, arginfo_class_ReflectionFunctionAbstract_isDeprecated, ZEND_ACC_PUBLIC)
@@ -988,7 +988,7 @@ static const zend_function_entry class_ReflectionClass_methods[] = {
 	ZEND_ME(ReflectionClass, setStaticPropertyValue, arginfo_class_ReflectionClass_setStaticPropertyValue, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getDefaultProperties, arginfo_class_ReflectionClass_getDefaultProperties, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, isIterable, arginfo_class_ReflectionClass_isIterable, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ReflectionClass, isIterateable, isIterable, arginfo_class_ReflectionClass_isIterateable, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("isIterateable", zim_ReflectionClass_isIterable, arginfo_class_ReflectionClass_isIterateable, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(ReflectionClass, implementsInterface, arginfo_class_ReflectionClass_implementsInterface, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getExtension, arginfo_class_ReflectionClass_getExtension, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getExtensionName, arginfo_class_ReflectionClass_getExtensionName, ZEND_ACC_PUBLIC)
@@ -1005,7 +1005,7 @@ static const zend_function_entry class_ReflectionObject_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionProperty_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionProperty___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionProperty___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionProperty, __construct, arginfo_class_ReflectionProperty___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionProperty, __toString, arginfo_class_ReflectionProperty___toString, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionProperty, getName, arginfo_class_ReflectionProperty_getName, ZEND_ACC_PUBLIC)
@@ -1032,7 +1032,7 @@ static const zend_function_entry class_ReflectionProperty_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionClassConstant_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionClassConstant___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionClassConstant___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionClassConstant, __construct, arginfo_class_ReflectionClassConstant___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClassConstant, __toString, arginfo_class_ReflectionClassConstant___toString, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClassConstant, getName, arginfo_class_ReflectionClassConstant_getName, ZEND_ACC_PUBLIC)
@@ -1052,7 +1052,7 @@ static const zend_function_entry class_ReflectionClassConstant_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionParameter_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionParameter___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionParameter___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionParameter, __construct, arginfo_class_ReflectionParameter___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionParameter, __toString, arginfo_class_ReflectionParameter___toString, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionParameter, getName, arginfo_class_ReflectionParameter_getName, ZEND_ACC_PUBLIC)
@@ -1079,7 +1079,7 @@ static const zend_function_entry class_ReflectionParameter_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionType_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionType___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionType___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionType, allowsNull, arginfo_class_ReflectionType_allowsNull, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionType, __toString, arginfo_class_ReflectionType___toString, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
@@ -1102,7 +1102,7 @@ static const zend_function_entry class_ReflectionIntersectionType_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionExtension_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionExtension___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionExtension___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionExtension, __construct, arginfo_class_ReflectionExtension___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionExtension, __toString, arginfo_class_ReflectionExtension___toString, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionExtension, getName, arginfo_class_ReflectionExtension_getName, ZEND_ACC_PUBLIC)
@@ -1120,7 +1120,7 @@ static const zend_function_entry class_ReflectionExtension_methods[] = {
 };
 
 static const zend_function_entry class_ReflectionZendExtension_methods[] = {
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionZendExtension___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionZendExtension___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionZendExtension, __construct, arginfo_class_ReflectionZendExtension___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionZendExtension, __toString, arginfo_class_ReflectionZendExtension___toString, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionZendExtension, getName, arginfo_class_ReflectionZendExtension_getName, ZEND_ACC_PUBLIC)
@@ -1134,7 +1134,7 @@ static const zend_function_entry class_ReflectionZendExtension_methods[] = {
 static const zend_function_entry class_ReflectionReference_methods[] = {
 	ZEND_ME(ReflectionReference, fromArrayElement, arginfo_class_ReflectionReference_fromArrayElement, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(ReflectionReference, getId, arginfo_class_ReflectionReference_getId, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ReflectionClass, __clone, __clone, arginfo_class_ReflectionReference___clone, ZEND_ACC_PRIVATE)
+	ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionReference___clone, ZEND_ACC_PRIVATE, NULL, NULL)
 	ZEND_ME(ReflectionReference, __construct, arginfo_class_ReflectionReference___construct, ZEND_ACC_PRIVATE)
 	ZEND_FE_END
 };
@@ -1164,7 +1164,7 @@ static const zend_function_entry class_ReflectionEnum_methods[] = {
 static const zend_function_entry class_ReflectionEnumUnitCase_methods[] = {
 	ZEND_ME(ReflectionEnumUnitCase, __construct, arginfo_class_ReflectionEnumUnitCase___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionEnumUnitCase, getEnum, arginfo_class_ReflectionEnumUnitCase_getEnum, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ReflectionClassConstant, getValue, getValue, arginfo_class_ReflectionEnumUnitCase_getValue, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getValue", zim_ReflectionClassConstant_getValue, arginfo_class_ReflectionEnumUnitCase_getValue, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/reflection/tests/ReflectionClassConstant_basic1.phpt b/ext/reflection/tests/ReflectionClassConstant_basic1.phpt
index 33d923d97130c..4b8c8a32f7854 100644
--- a/ext/reflection/tests/ReflectionClassConstant_basic1.phpt
+++ b/ext/reflection/tests/ReflectionClassConstant_basic1.phpt
@@ -57,7 +57,8 @@ reflectClassConstant($instance, "BAD_CONST");
 Reflecting on class constant TestClass::PUB
 
 __toString():
-string(35) "Constant [ public bool PUB ] { 1 }
+string(57) "/** My Doc comment */
+Constant [ public bool PUB ] { 1 }
 "
 getName():
 string(3) "PUB"
@@ -89,7 +90,8 @@ bool
 Reflecting on class constant TestClass::PROT
 
 __toString():
-string(38) "Constant [ protected int PROT ] { 4 }
+string(65) "/** Another doc comment */
+Constant [ protected int PROT ] { 4 }
 "
 getName():
 string(4) "PROT"
diff --git a/ext/reflection/tests/constructor_promotion.phpt b/ext/reflection/tests/constructor_promotion.phpt
index d0a09aaee048f..b18ff459c4431 100644
--- a/ext/reflection/tests/constructor_promotion.phpt
+++ b/ext/reflection/tests/constructor_promotion.phpt
@@ -46,6 +46,7 @@ Class [ <user> class Test ] {
   - Properties [3] {
     Property [ public $z = NULL ]
     Property [ public int $x ]
+    /** @SomeAnnotation() */
     Property [ public string $y ]
   }
 
diff --git a/ext/session/session_arginfo.h b/ext/session/session_arginfo.h
index 964c623c6ba2f..a1fe34cfde3e8 100644
--- a/ext/session/session_arginfo.h
+++ b/ext/session/session_arginfo.h
@@ -183,7 +183,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(session_reset, arginfo_session_reset)
 	ZEND_FE(session_status, arginfo_session_status)
 	ZEND_FE(session_register_shutdown, arginfo_session_register_shutdown)
-	ZEND_FALIAS(session_commit, session_write_close, arginfo_session_commit)
+	ZEND_RAW_FENTRY("session_commit", zif_session_write_close, arginfo_session_commit, 0, NULL, NULL)
 	ZEND_FE(session_set_save_handler, arginfo_session_set_save_handler)
 	ZEND_FE(session_cache_limiter, arginfo_session_cache_limiter)
 	ZEND_FE(session_cache_expire, arginfo_session_cache_expire)
@@ -193,23 +193,23 @@ static const zend_function_entry ext_functions[] = {
 };
 
 static const zend_function_entry class_SessionHandlerInterface_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, open, arginfo_class_SessionHandlerInterface_open, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, close, arginfo_class_SessionHandlerInterface_close, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, read, arginfo_class_SessionHandlerInterface_read, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, write, arginfo_class_SessionHandlerInterface_write, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, destroy, arginfo_class_SessionHandlerInterface_destroy, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionHandlerInterface, gc, arginfo_class_SessionHandlerInterface_gc, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("open", NULL, arginfo_class_SessionHandlerInterface_open, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("close", NULL, arginfo_class_SessionHandlerInterface_close, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("read", NULL, arginfo_class_SessionHandlerInterface_read, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("write", NULL, arginfo_class_SessionHandlerInterface_write, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("destroy", NULL, arginfo_class_SessionHandlerInterface_destroy, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("gc", NULL, arginfo_class_SessionHandlerInterface_gc, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_SessionIdInterface_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionIdInterface, create_sid, arginfo_class_SessionIdInterface_create_sid, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("create_sid", NULL, arginfo_class_SessionIdInterface_create_sid, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_SessionUpdateTimestampHandlerInterface_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionUpdateTimestampHandlerInterface, validateId, arginfo_class_SessionUpdateTimestampHandlerInterface_validateId, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SessionUpdateTimestampHandlerInterface, updateTimestamp, arginfo_class_SessionUpdateTimestampHandlerInterface_updateTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("validateId", NULL, arginfo_class_SessionUpdateTimestampHandlerInterface_validateId, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("updateTimestamp", NULL, arginfo_class_SessionUpdateTimestampHandlerInterface_updateTimestamp, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/shmop/shmop_arginfo.h b/ext/shmop/shmop_arginfo.h
index a74f416fad9c1..e59f6a1da8e1a 100644
--- a/ext/shmop/shmop_arginfo.h
+++ b/ext/shmop/shmop_arginfo.h
@@ -42,7 +42,7 @@ ZEND_FUNCTION(shmop_delete);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(shmop_open, arginfo_shmop_open)
 	ZEND_FE(shmop_read, arginfo_shmop_read)
-	ZEND_DEP_FE(shmop_close, arginfo_shmop_close)
+	ZEND_RAW_FENTRY("shmop_close", zif_shmop_close, arginfo_shmop_close, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE(shmop_size, arginfo_shmop_size)
 	ZEND_FE(shmop_write, arginfo_shmop_write)
 	ZEND_FE(shmop_delete, arginfo_shmop_delete)
diff --git a/ext/simplexml/simplexml_arginfo.h b/ext/simplexml/simplexml_arginfo.h
index 8f49eb1322eaf..285df20813f07 100644
--- a/ext/simplexml/simplexml_arginfo.h
+++ b/ext/simplexml/simplexml_arginfo.h
@@ -135,7 +135,7 @@ static const zend_function_entry class_SimpleXMLElement_methods[] = {
 	ZEND_ME(SimpleXMLElement, xpath, arginfo_class_SimpleXMLElement_xpath, ZEND_ACC_PUBLIC)
 	ZEND_ME(SimpleXMLElement, registerXPathNamespace, arginfo_class_SimpleXMLElement_registerXPathNamespace, ZEND_ACC_PUBLIC)
 	ZEND_ME(SimpleXMLElement, asXML, arginfo_class_SimpleXMLElement_asXML, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SimpleXMLElement, saveXML, asXML, arginfo_class_SimpleXMLElement_saveXML, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("saveXML", zim_SimpleXMLElement_asXML, arginfo_class_SimpleXMLElement_saveXML, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SimpleXMLElement, getNamespaces, arginfo_class_SimpleXMLElement_getNamespaces, ZEND_ACC_PUBLIC)
 	ZEND_ME(SimpleXMLElement, getDocNamespaces, arginfo_class_SimpleXMLElement_getDocNamespaces, ZEND_ACC_PUBLIC)
 	ZEND_ME(SimpleXMLElement, children, arginfo_class_SimpleXMLElement_children, ZEND_ACC_PUBLIC)
diff --git a/ext/snmp/snmp_arginfo.h b/ext/snmp/snmp_arginfo.h
index 606487238774c..60a91c61b550d 100644
--- a/ext/snmp/snmp_arginfo.h
+++ b/ext/snmp/snmp_arginfo.h
@@ -200,13 +200,13 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(snmpgetnext, arginfo_snmpgetnext)
 	ZEND_FE(snmpwalk, arginfo_snmpwalk)
 	ZEND_FE(snmprealwalk, arginfo_snmprealwalk)
-	ZEND_FALIAS(snmpwalkoid, snmprealwalk, arginfo_snmpwalkoid)
+	ZEND_RAW_FENTRY("snmpwalkoid", zif_snmprealwalk, arginfo_snmpwalkoid, 0, NULL, NULL)
 	ZEND_FE(snmpset, arginfo_snmpset)
 	ZEND_FE(snmp_get_quick_print, arginfo_snmp_get_quick_print)
 	ZEND_FE(snmp_set_quick_print, arginfo_snmp_set_quick_print)
 	ZEND_FE(snmp_set_enum_print, arginfo_snmp_set_enum_print)
 	ZEND_FE(snmp_set_oid_output_format, arginfo_snmp_set_oid_output_format)
-	ZEND_FALIAS(snmp_set_oid_numeric_print, snmp_set_oid_output_format, arginfo_snmp_set_oid_numeric_print)
+	ZEND_RAW_FENTRY("snmp_set_oid_numeric_print", zif_snmp_set_oid_output_format, arginfo_snmp_set_oid_numeric_print, 0, NULL, NULL)
 	ZEND_FE(snmp2_get, arginfo_snmp2_get)
 	ZEND_FE(snmp2_getnext, arginfo_snmp2_getnext)
 	ZEND_FE(snmp2_walk, arginfo_snmp2_walk)
diff --git a/ext/sockets/sockets_arginfo.h b/ext/sockets/sockets_arginfo.h
index 9b43346766cb6..2e03ad7f4d116 100644
--- a/ext/sockets/sockets_arginfo.h
+++ b/ext/sockets/sockets_arginfo.h
@@ -287,9 +287,9 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(socket_recvfrom, arginfo_socket_recvfrom)
 	ZEND_FE(socket_sendto, arginfo_socket_sendto)
 	ZEND_FE(socket_get_option, arginfo_socket_get_option)
-	ZEND_FALIAS(socket_getopt, socket_get_option, arginfo_socket_getopt)
+	ZEND_RAW_FENTRY("socket_getopt", zif_socket_get_option, arginfo_socket_getopt, 0, NULL, NULL)
 	ZEND_FE(socket_set_option, arginfo_socket_set_option)
-	ZEND_FALIAS(socket_setopt, socket_set_option, arginfo_socket_setopt)
+	ZEND_RAW_FENTRY("socket_setopt", zif_socket_set_option, arginfo_socket_setopt, 0, NULL, NULL)
 #if defined(HAVE_SOCKETPAIR)
 	ZEND_FE(socket_create_pair, arginfo_socket_create_pair)
 #endif
diff --git a/ext/sodium/libsodium_arginfo.h b/ext/sodium/libsodium_arginfo.h
index 65ea911d7f5f5..ebc5fadae6452 100644
--- a/ext/sodium/libsodium_arginfo.h
+++ b/ext/sodium/libsodium_arginfo.h
@@ -955,7 +955,7 @@ static const zend_function_entry ext_functions[] = {
 #if defined(sodium_base64_VARIANT_ORIGINAL)
 	ZEND_FE(sodium_base642bin, arginfo_sodium_base642bin)
 #endif
-	ZEND_FALIAS(sodium_crypto_scalarmult_base, sodium_crypto_box_publickey_from_secretkey, arginfo_sodium_crypto_scalarmult_base)
+	ZEND_RAW_FENTRY("sodium_crypto_scalarmult_base", zif_sodium_crypto_box_publickey_from_secretkey, arginfo_sodium_crypto_scalarmult_base, 0, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/spl/spl_array_arginfo.h b/ext/spl/spl_array_arginfo.h
index 22f986b8cd1ec..e846943c3cbfe 100644
--- a/ext/spl/spl_array_arginfo.h
+++ b/ext/spl/spl_array_arginfo.h
@@ -219,32 +219,32 @@ static const zend_function_entry class_ArrayObject_methods[] = {
 
 static const zend_function_entry class_ArrayIterator_methods[] = {
 	ZEND_ME(ArrayIterator, __construct, arginfo_class_ArrayIterator___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, offsetExists, offsetExists, arginfo_class_ArrayIterator_offsetExists, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, offsetGet, offsetGet, arginfo_class_ArrayIterator_offsetGet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, offsetSet, offsetSet, arginfo_class_ArrayIterator_offsetSet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, offsetUnset, offsetUnset, arginfo_class_ArrayIterator_offsetUnset, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, append, append, arginfo_class_ArrayIterator_append, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, getArrayCopy, getArrayCopy, arginfo_class_ArrayIterator_getArrayCopy, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, count, count, arginfo_class_ArrayIterator_count, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, getFlags, getFlags, arginfo_class_ArrayIterator_getFlags, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, setFlags, setFlags, arginfo_class_ArrayIterator_setFlags, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, asort, asort, arginfo_class_ArrayIterator_asort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, ksort, ksort, arginfo_class_ArrayIterator_ksort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, uasort, uasort, arginfo_class_ArrayIterator_uasort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, uksort, uksort, arginfo_class_ArrayIterator_uksort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, natsort, natsort, arginfo_class_ArrayIterator_natsort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, natcasesort, natcasesort, arginfo_class_ArrayIterator_natcasesort, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, unserialize, unserialize, arginfo_class_ArrayIterator_unserialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, serialize, serialize, arginfo_class_ArrayIterator_serialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, __serialize, __serialize, arginfo_class_ArrayIterator___serialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, __unserialize, __unserialize, arginfo_class_ArrayIterator___unserialize, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("offsetExists", zim_ArrayObject_offsetExists, arginfo_class_ArrayIterator_offsetExists, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetGet", zim_ArrayObject_offsetGet, arginfo_class_ArrayIterator_offsetGet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetSet", zim_ArrayObject_offsetSet, arginfo_class_ArrayIterator_offsetSet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetUnset", zim_ArrayObject_offsetUnset, arginfo_class_ArrayIterator_offsetUnset, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("append", zim_ArrayObject_append, arginfo_class_ArrayIterator_append, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getArrayCopy", zim_ArrayObject_getArrayCopy, arginfo_class_ArrayIterator_getArrayCopy, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("count", zim_ArrayObject_count, arginfo_class_ArrayIterator_count, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getFlags", zim_ArrayObject_getFlags, arginfo_class_ArrayIterator_getFlags, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setFlags", zim_ArrayObject_setFlags, arginfo_class_ArrayIterator_setFlags, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("asort", zim_ArrayObject_asort, arginfo_class_ArrayIterator_asort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("ksort", zim_ArrayObject_ksort, arginfo_class_ArrayIterator_ksort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("uasort", zim_ArrayObject_uasort, arginfo_class_ArrayIterator_uasort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("uksort", zim_ArrayObject_uksort, arginfo_class_ArrayIterator_uksort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("natsort", zim_ArrayObject_natsort, arginfo_class_ArrayIterator_natsort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("natcasesort", zim_ArrayObject_natcasesort, arginfo_class_ArrayIterator_natcasesort, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("unserialize", zim_ArrayObject_unserialize, arginfo_class_ArrayIterator_unserialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("serialize", zim_ArrayObject_serialize, arginfo_class_ArrayIterator_serialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__serialize", zim_ArrayObject___serialize, arginfo_class_ArrayIterator___serialize, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("__unserialize", zim_ArrayObject___unserialize, arginfo_class_ArrayIterator___unserialize, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(ArrayIterator, rewind, arginfo_class_ArrayIterator_rewind, ZEND_ACC_PUBLIC)
 	ZEND_ME(ArrayIterator, current, arginfo_class_ArrayIterator_current, ZEND_ACC_PUBLIC)
 	ZEND_ME(ArrayIterator, key, arginfo_class_ArrayIterator_key, ZEND_ACC_PUBLIC)
 	ZEND_ME(ArrayIterator, next, arginfo_class_ArrayIterator_next, ZEND_ACC_PUBLIC)
 	ZEND_ME(ArrayIterator, valid, arginfo_class_ArrayIterator_valid, ZEND_ACC_PUBLIC)
 	ZEND_ME(ArrayIterator, seek, arginfo_class_ArrayIterator_seek, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(ArrayObject, __debugInfo, __debugInfo, arginfo_class_ArrayIterator___debugInfo, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__debugInfo", zim_ArrayObject___debugInfo, arginfo_class_ArrayIterator___debugInfo, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/spl/spl_directory_arginfo.h b/ext/spl/spl_directory_arginfo.h
index d28ec1e29f487..aa258b42b91cf 100644
--- a/ext/spl/spl_directory_arginfo.h
+++ b/ext/spl/spl_directory_arginfo.h
@@ -392,7 +392,7 @@ static const zend_function_entry class_SplFileInfo_methods[] = {
 	ZEND_ME(SplFileInfo, openFile, arginfo_class_SplFileInfo_openFile, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplFileInfo, setFileClass, arginfo_class_SplFileInfo_setFileClass, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplFileInfo, setInfoClass, arginfo_class_SplFileInfo_setInfoClass, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplFileInfo, __toString, getPathname, arginfo_class_SplFileInfo___toString, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__toString", zim_SplFileInfo_getPathname, arginfo_class_SplFileInfo___toString, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplFileInfo, __debugInfo, arginfo_class_SplFileInfo___debugInfo, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplFileInfo, _bad_state_ex, arginfo_class_SplFileInfo__bad_state_ex, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL|ZEND_ACC_DEPRECATED)
 	ZEND_FE_END
@@ -410,7 +410,7 @@ static const zend_function_entry class_DirectoryIterator_methods[] = {
 	ZEND_ME(DirectoryIterator, current, arginfo_class_DirectoryIterator_current, ZEND_ACC_PUBLIC)
 	ZEND_ME(DirectoryIterator, next, arginfo_class_DirectoryIterator_next, ZEND_ACC_PUBLIC)
 	ZEND_ME(DirectoryIterator, seek, arginfo_class_DirectoryIterator_seek, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(DirectoryIterator, __toString, getFilename, arginfo_class_DirectoryIterator___toString, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__toString", zim_DirectoryIterator_getFilename, arginfo_class_DirectoryIterator___toString, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -472,7 +472,7 @@ static const zend_function_entry class_SplFileObject_methods[] = {
 	ZEND_ME(SplFileObject, hasChildren, arginfo_class_SplFileObject_hasChildren, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplFileObject, getChildren, arginfo_class_SplFileObject_getChildren, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplFileObject, seek, arginfo_class_SplFileObject_seek, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplFileObject, getCurrentLine, fgets, arginfo_class_SplFileObject_getCurrentLine, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getCurrentLine", zim_SplFileObject_fgets, arginfo_class_SplFileObject_getCurrentLine, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplFileObject, __toString, arginfo_class_SplFileObject___toString, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
diff --git a/ext/spl/spl_dllist_arginfo.h b/ext/spl/spl_dllist_arginfo.h
index e6998c3476645..aa87f686bb70d 100644
--- a/ext/spl/spl_dllist_arginfo.h
+++ b/ext/spl/spl_dllist_arginfo.h
@@ -141,8 +141,8 @@ static const zend_function_entry class_SplDoublyLinkedList_methods[] = {
 };
 
 static const zend_function_entry class_SplQueue_methods[] = {
-	ZEND_MALIAS(SplDoublyLinkedList, enqueue, push, arginfo_class_SplQueue_enqueue, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplDoublyLinkedList, dequeue, shift, arginfo_class_SplQueue_dequeue, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("enqueue", zim_SplDoublyLinkedList_push, arginfo_class_SplQueue_enqueue, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("dequeue", zim_SplDoublyLinkedList_shift, arginfo_class_SplQueue_dequeue, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/spl/spl_heap_arginfo.h b/ext/spl/spl_heap_arginfo.h
index 53e94b886ab91..9910ae15cd988 100644
--- a/ext/spl/spl_heap_arginfo.h
+++ b/ext/spl/spl_heap_arginfo.h
@@ -114,15 +114,15 @@ static const zend_function_entry class_SplPriorityQueue_methods[] = {
 	ZEND_ME(SplPriorityQueue, setExtractFlags, arginfo_class_SplPriorityQueue_setExtractFlags, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplPriorityQueue, top, arginfo_class_SplPriorityQueue_top, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplPriorityQueue, extract, arginfo_class_SplPriorityQueue_extract, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, count, count, arginfo_class_SplPriorityQueue_count, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, isEmpty, isEmpty, arginfo_class_SplPriorityQueue_isEmpty, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, rewind, rewind, arginfo_class_SplPriorityQueue_rewind, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("count", zim_SplHeap_count, arginfo_class_SplPriorityQueue_count, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isEmpty", zim_SplHeap_isEmpty, arginfo_class_SplPriorityQueue_isEmpty, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("rewind", zim_SplHeap_rewind, arginfo_class_SplPriorityQueue_rewind, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplPriorityQueue, current, arginfo_class_SplPriorityQueue_current, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, key, key, arginfo_class_SplPriorityQueue_key, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, next, next, arginfo_class_SplPriorityQueue_next, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, valid, valid, arginfo_class_SplPriorityQueue_valid, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, recoverFromCorruption, recoverFromCorruption, arginfo_class_SplPriorityQueue_recoverFromCorruption, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplHeap, isCorrupted, isCorrupted, arginfo_class_SplPriorityQueue_isCorrupted, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("key", zim_SplHeap_key, arginfo_class_SplPriorityQueue_key, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("next", zim_SplHeap_next, arginfo_class_SplPriorityQueue_next, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("valid", zim_SplHeap_valid, arginfo_class_SplPriorityQueue_valid, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("recoverFromCorruption", zim_SplHeap_recoverFromCorruption, arginfo_class_SplPriorityQueue_recoverFromCorruption, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isCorrupted", zim_SplHeap_isCorrupted, arginfo_class_SplPriorityQueue_isCorrupted, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplPriorityQueue, getExtractFlags, arginfo_class_SplPriorityQueue_getExtractFlags, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplPriorityQueue, __debugInfo, arginfo_class_SplPriorityQueue___debugInfo, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
@@ -140,7 +140,7 @@ static const zend_function_entry class_SplHeap_methods[] = {
 	ZEND_ME(SplHeap, next, arginfo_class_SplHeap_next, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplHeap, valid, arginfo_class_SplHeap_valid, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplHeap, recoverFromCorruption, arginfo_class_SplHeap_recoverFromCorruption, ZEND_ACC_PUBLIC)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SplHeap, compare, arginfo_class_SplHeap_compare, ZEND_ACC_PROTECTED|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("compare", NULL, arginfo_class_SplHeap_compare, ZEND_ACC_PROTECTED|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_ME(SplHeap, isCorrupted, arginfo_class_SplHeap_isCorrupted, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplHeap, __debugInfo, arginfo_class_SplHeap___debugInfo, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
diff --git a/ext/spl/spl_iterators_arginfo.h b/ext/spl/spl_iterators_arginfo.h
index b408728b25ec0..1d6566f6c6908 100644
--- a/ext/spl/spl_iterators_arginfo.h
+++ b/ext/spl/spl_iterators_arginfo.h
@@ -429,14 +429,14 @@ static const zend_function_entry class_CallbackFilterIterator_methods[] = {
 
 static const zend_function_entry class_RecursiveCallbackFilterIterator_methods[] = {
 	ZEND_ME(RecursiveCallbackFilterIterator, __construct, arginfo_class_RecursiveCallbackFilterIterator___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(RecursiveFilterIterator, hasChildren, hasChildren, arginfo_class_RecursiveCallbackFilterIterator_hasChildren, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("hasChildren", zim_RecursiveFilterIterator_hasChildren, arginfo_class_RecursiveCallbackFilterIterator_hasChildren, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(RecursiveCallbackFilterIterator, getChildren, arginfo_class_RecursiveCallbackFilterIterator_getChildren, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_RecursiveIterator_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(RecursiveIterator, hasChildren, arginfo_class_RecursiveIterator_hasChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(RecursiveIterator, getChildren, arginfo_class_RecursiveIterator_getChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("hasChildren", NULL, arginfo_class_RecursiveIterator_hasChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("getChildren", NULL, arginfo_class_RecursiveIterator_getChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -463,7 +463,7 @@ static const zend_function_entry class_RecursiveIteratorIterator_methods[] = {
 };
 
 static const zend_function_entry class_OuterIterator_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(OuterIterator, getInnerIterator, arginfo_class_OuterIterator_getInnerIterator, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("getInnerIterator", NULL, arginfo_class_OuterIterator_getInnerIterator, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -479,7 +479,7 @@ static const zend_function_entry class_IteratorIterator_methods[] = {
 };
 
 static const zend_function_entry class_FilterIterator_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(FilterIterator, accept, arginfo_class_FilterIterator_accept, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("accept", NULL, arginfo_class_FilterIterator_accept, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_ME(FilterIterator, __construct, arginfo_class_FilterIterator___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(FilterIterator, rewind, arginfo_class_FilterIterator_rewind, ZEND_ACC_PUBLIC)
 	ZEND_ME(FilterIterator, next, arginfo_class_FilterIterator_next, ZEND_ACC_PUBLIC)
@@ -495,12 +495,12 @@ static const zend_function_entry class_RecursiveFilterIterator_methods[] = {
 
 static const zend_function_entry class_ParentIterator_methods[] = {
 	ZEND_ME(ParentIterator, __construct, arginfo_class_ParentIterator___construct, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(RecursiveFilterIterator, accept, hasChildren, arginfo_class_ParentIterator_accept, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("accept", zim_RecursiveFilterIterator_hasChildren, arginfo_class_ParentIterator_accept, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_SeekableIterator_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SeekableIterator, seek, arginfo_class_SeekableIterator_seek, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("seek", NULL, arginfo_class_SeekableIterator_seek, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -583,7 +583,7 @@ static const zend_function_entry class_RegexIterator_methods[] = {
 static const zend_function_entry class_RecursiveRegexIterator_methods[] = {
 	ZEND_ME(RecursiveRegexIterator, __construct, arginfo_class_RecursiveRegexIterator___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(RecursiveRegexIterator, accept, arginfo_class_RecursiveRegexIterator_accept, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(RecursiveFilterIterator, hasChildren, hasChildren, arginfo_class_RecursiveRegexIterator_hasChildren, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("hasChildren", zim_RecursiveFilterIterator_hasChildren, arginfo_class_RecursiveRegexIterator_hasChildren, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(RecursiveRegexIterator, getChildren, arginfo_class_RecursiveRegexIterator_getChildren, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
diff --git a/ext/spl/spl_observer_arginfo.h b/ext/spl/spl_observer_arginfo.h
index abef8ee3d4054..b395897917711 100644
--- a/ext/spl/spl_observer_arginfo.h
+++ b/ext/spl/spl_observer_arginfo.h
@@ -168,14 +168,14 @@ ZEND_METHOD(MultipleIterator, current);
 ZEND_METHOD(MultipleIterator, next);
 
 static const zend_function_entry class_SplObserver_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SplObserver, update, arginfo_class_SplObserver_update, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("update", NULL, arginfo_class_SplObserver_update, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
 static const zend_function_entry class_SplSubject_methods[] = {
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, attach, arginfo_class_SplSubject_attach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, detach, arginfo_class_SplSubject_detach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
-	ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, notify, arginfo_class_SplSubject_notify, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+	ZEND_RAW_FENTRY("attach", NULL, arginfo_class_SplSubject_attach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("detach", NULL, arginfo_class_SplSubject_detach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("notify", NULL, arginfo_class_SplSubject_notify, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
 	ZEND_FE_END
 };
 
@@ -196,10 +196,10 @@ static const zend_function_entry class_SplObjectStorage_methods[] = {
 	ZEND_ME(SplObjectStorage, next, arginfo_class_SplObjectStorage_next, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplObjectStorage, unserialize, arginfo_class_SplObjectStorage_unserialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplObjectStorage, serialize, arginfo_class_SplObjectStorage_serialize, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplObjectStorage, offsetExists, contains, arginfo_class_SplObjectStorage_offsetExists, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("offsetExists", zim_SplObjectStorage_contains, arginfo_class_SplObjectStorage_offsetExists, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplObjectStorage, offsetGet, arginfo_class_SplObjectStorage_offsetGet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplObjectStorage, offsetSet, attach, arginfo_class_SplObjectStorage_offsetSet, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplObjectStorage, offsetUnset, detach, arginfo_class_SplObjectStorage_offsetUnset, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("offsetSet", zim_SplObjectStorage_attach, arginfo_class_SplObjectStorage_offsetSet, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("offsetUnset", zim_SplObjectStorage_detach, arginfo_class_SplObjectStorage_offsetUnset, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SplObjectStorage, getHash, arginfo_class_SplObjectStorage_getHash, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplObjectStorage, __serialize, arginfo_class_SplObjectStorage___serialize, ZEND_ACC_PUBLIC)
 	ZEND_ME(SplObjectStorage, __unserialize, arginfo_class_SplObjectStorage___unserialize, ZEND_ACC_PUBLIC)
@@ -220,7 +220,7 @@ static const zend_function_entry class_MultipleIterator_methods[] = {
 	ZEND_ME(MultipleIterator, key, arginfo_class_MultipleIterator_key, ZEND_ACC_PUBLIC)
 	ZEND_ME(MultipleIterator, current, arginfo_class_MultipleIterator_current, ZEND_ACC_PUBLIC)
 	ZEND_ME(MultipleIterator, next, arginfo_class_MultipleIterator_next, ZEND_ACC_PUBLIC)
-	ZEND_MALIAS(SplObjectStorage, __debugInfo, __debugInfo, arginfo_class_MultipleIterator___debugInfo, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__debugInfo", zim_SplObjectStorage___debugInfo, arginfo_class_MultipleIterator___debugInfo, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/sqlite3/sqlite3_arginfo.h b/ext/sqlite3/sqlite3_arginfo.h
index bffd0dc3576a3..bc3caf4096237 100644
--- a/ext/sqlite3/sqlite3_arginfo.h
+++ b/ext/sqlite3/sqlite3_arginfo.h
@@ -214,7 +214,7 @@ static const zend_function_entry class_SQLite3Exception_methods[] = {
 };
 
 static const zend_function_entry class_SQLite3_methods[] = {
-	ZEND_MALIAS(SQLite3, __construct, open, arginfo_class_SQLite3___construct, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("__construct", zim_SQLite3_open, arginfo_class_SQLite3___construct, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(SQLite3, open, arginfo_class_SQLite3_open, ZEND_ACC_PUBLIC)
 	ZEND_ME(SQLite3, close, arginfo_class_SQLite3_close, ZEND_ACC_PUBLIC)
 	ZEND_ME(SQLite3, version, arginfo_class_SQLite3_version, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index b08e1c2affb2e..e1004480ece6a 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -2943,14 +2943,14 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(output_reset_rewrite_vars, arginfo_output_reset_rewrite_vars)
 	ZEND_FE(output_add_rewrite_var, arginfo_output_add_rewrite_var)
 	ZEND_FE(stream_wrapper_register, arginfo_stream_wrapper_register)
-	ZEND_FALIAS(stream_register_wrapper, stream_wrapper_register, arginfo_stream_register_wrapper)
+	ZEND_RAW_FENTRY("stream_register_wrapper", zif_stream_wrapper_register, arginfo_stream_register_wrapper, 0, NULL, NULL)
 	ZEND_FE(stream_wrapper_unregister, arginfo_stream_wrapper_unregister)
 	ZEND_FE(stream_wrapper_restore, arginfo_stream_wrapper_restore)
 	ZEND_FE(array_push, arginfo_array_push)
 	ZEND_FE(krsort, arginfo_krsort)
 	ZEND_FE(ksort, arginfo_ksort)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(count, arginfo_count)
-	ZEND_FALIAS(sizeof, count, arginfo_sizeof)
+	ZEND_RAW_FENTRY("count", zif_count, arginfo_count, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("sizeof", zif_count, arginfo_sizeof, 0, NULL, NULL)
 	ZEND_FE(natsort, arginfo_natsort)
 	ZEND_FE(natcasesort, arginfo_natcasesort)
 	ZEND_FE(asort, arginfo_asort)
@@ -2965,14 +2965,14 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(next, arginfo_next)
 	ZEND_FE(reset, arginfo_reset)
 	ZEND_FE(current, arginfo_current)
-	ZEND_FALIAS(pos, current, arginfo_pos)
+	ZEND_RAW_FENTRY("pos", zif_current, arginfo_pos, 0, NULL, NULL)
 	ZEND_FE(key, arginfo_key)
-	ZEND_FRAMELESS_FE(min, arginfo_min, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_min)
-	ZEND_FRAMELESS_FE(max, arginfo_max, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_max)
+	ZEND_RAW_FENTRY("min", zif_min, arginfo_min, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_min, NULL)
+	ZEND_RAW_FENTRY("max", zif_max, arginfo_max, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_max, NULL)
 	ZEND_FE(array_walk, arginfo_array_walk)
 	ZEND_FE(array_walk_recursive, arginfo_array_walk_recursive)
-	ZEND_FRAMELESS_FE(in_array, arginfo_in_array, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_in_array)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_search, arginfo_array_search)
+	ZEND_RAW_FENTRY("in_array", zif_in_array, arginfo_in_array, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_in_array, NULL)
+	ZEND_RAW_FENTRY("array_search", zif_array_search, arginfo_array_search, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(extract, arginfo_extract)
 	ZEND_FE(compact, arginfo_compact)
 	ZEND_FE(array_fill, arginfo_array_fill)
@@ -2983,52 +2983,52 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(array_shift, arginfo_array_shift)
 	ZEND_FE(array_unshift, arginfo_array_unshift)
 	ZEND_FE(array_splice, arginfo_array_splice)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_slice, arginfo_array_slice)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_merge, arginfo_array_merge)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_merge_recursive, arginfo_array_merge_recursive)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_replace, arginfo_array_replace)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_replace_recursive, arginfo_array_replace_recursive)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_keys, arginfo_array_keys)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_key_first, arginfo_array_key_first)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_key_last, arginfo_array_key_last)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_values, arginfo_array_values)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_count_values, arginfo_array_count_values)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_column, arginfo_array_column)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_reverse, arginfo_array_reverse)
+	ZEND_RAW_FENTRY("array_slice", zif_array_slice, arginfo_array_slice, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_merge", zif_array_merge, arginfo_array_merge, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_merge_recursive", zif_array_merge_recursive, arginfo_array_merge_recursive, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_replace", zif_array_replace, arginfo_array_replace, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_replace_recursive", zif_array_replace_recursive, arginfo_array_replace_recursive, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_keys", zif_array_keys, arginfo_array_keys, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_key_first", zif_array_key_first, arginfo_array_key_first, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_key_last", zif_array_key_last, arginfo_array_key_last, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_values", zif_array_values, arginfo_array_values, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_count_values", zif_array_count_values, arginfo_array_count_values, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_column", zif_array_column, arginfo_array_column, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_reverse", zif_array_reverse, arginfo_array_reverse, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_pad, arginfo_array_pad)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_flip, arginfo_array_flip)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_change_key_case, arginfo_array_change_key_case)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_unique, arginfo_array_unique)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_intersect_key, arginfo_array_intersect_key)
+	ZEND_RAW_FENTRY("array_flip", zif_array_flip, arginfo_array_flip, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_change_key_case", zif_array_change_key_case, arginfo_array_change_key_case, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_unique", zif_array_unique, arginfo_array_unique, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_intersect_key", zif_array_intersect_key, arginfo_array_intersect_key, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_intersect_ukey, arginfo_array_intersect_ukey)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_intersect, arginfo_array_intersect)
+	ZEND_RAW_FENTRY("array_intersect", zif_array_intersect, arginfo_array_intersect, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_uintersect, arginfo_array_uintersect)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_intersect_assoc, arginfo_array_intersect_assoc)
+	ZEND_RAW_FENTRY("array_intersect_assoc", zif_array_intersect_assoc, arginfo_array_intersect_assoc, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_uintersect_assoc, arginfo_array_uintersect_assoc)
 	ZEND_FE(array_intersect_uassoc, arginfo_array_intersect_uassoc)
 	ZEND_FE(array_uintersect_uassoc, arginfo_array_uintersect_uassoc)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_diff_key, arginfo_array_diff_key)
+	ZEND_RAW_FENTRY("array_diff_key", zif_array_diff_key, arginfo_array_diff_key, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_diff_ukey, arginfo_array_diff_ukey)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_diff, arginfo_array_diff)
+	ZEND_RAW_FENTRY("array_diff", zif_array_diff, arginfo_array_diff, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_udiff, arginfo_array_udiff)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_diff_assoc, arginfo_array_diff_assoc)
+	ZEND_RAW_FENTRY("array_diff_assoc", zif_array_diff_assoc, arginfo_array_diff_assoc, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_diff_uassoc, arginfo_array_diff_uassoc)
 	ZEND_FE(array_udiff_assoc, arginfo_array_udiff_assoc)
 	ZEND_FE(array_udiff_uassoc, arginfo_array_udiff_uassoc)
 	ZEND_FE(array_multisort, arginfo_array_multisort)
 	ZEND_FE(array_rand, arginfo_array_rand)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_sum, arginfo_array_sum)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_product, arginfo_array_product)
+	ZEND_RAW_FENTRY("array_sum", zif_array_sum, arginfo_array_sum, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_product", zif_array_product, arginfo_array_product, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(array_reduce, arginfo_array_reduce)
 	ZEND_FE(array_filter, arginfo_array_filter)
 	ZEND_FE(array_map, arginfo_array_map)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_key_exists, arginfo_array_key_exists)
-	ZEND_FALIAS(key_exists, array_key_exists, arginfo_key_exists)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_chunk, arginfo_array_chunk)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_combine, arginfo_array_combine)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(array_is_list, arginfo_array_is_list)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(base64_encode, arginfo_base64_encode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(base64_decode, arginfo_base64_decode)
+	ZEND_RAW_FENTRY("array_key_exists", zif_array_key_exists, arginfo_array_key_exists, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("key_exists", zif_array_key_exists, arginfo_key_exists, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("array_chunk", zif_array_chunk, arginfo_array_chunk, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_combine", zif_array_combine, arginfo_array_combine, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("array_is_list", zif_array_is_list, arginfo_array_is_list, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("base64_encode", zif_base64_encode, arginfo_base64_encode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("base64_decode", zif_base64_decode, arginfo_base64_decode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(constant, arginfo_constant)
 	ZEND_FE(ip2long, arginfo_ip2long)
 	ZEND_FE(long2ip, arginfo_long2ip)
@@ -3057,13 +3057,13 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(forward_static_call_array, arginfo_forward_static_call_array)
 	ZEND_FE(register_shutdown_function, arginfo_register_shutdown_function)
 	ZEND_FE(highlight_file, arginfo_highlight_file)
-	ZEND_FALIAS(show_source, highlight_file, arginfo_show_source)
+	ZEND_RAW_FENTRY("show_source", zif_highlight_file, arginfo_show_source, 0, NULL, NULL)
 	ZEND_FE(php_strip_whitespace, arginfo_php_strip_whitespace)
 	ZEND_FE(highlight_string, arginfo_highlight_string)
 	ZEND_FE(ini_get, arginfo_ini_get)
 	ZEND_FE(ini_get_all, arginfo_ini_get_all)
 	ZEND_FE(ini_set, arginfo_ini_set)
-	ZEND_FALIAS(ini_alter, ini_set, arginfo_ini_alter)
+	ZEND_RAW_FENTRY("ini_alter", zif_ini_set, arginfo_ini_alter, 0, NULL, NULL)
 	ZEND_FE(ini_restore, arginfo_ini_restore)
 	ZEND_FE(ini_parse_quantity, arginfo_ini_parse_quantity)
 	ZEND_FE(set_include_path, arginfo_set_include_path)
@@ -3089,7 +3089,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(is_uploaded_file, arginfo_is_uploaded_file)
 	ZEND_FE(move_uploaded_file, arginfo_move_uploaded_file)
 	ZEND_FE(parse_ini_file, arginfo_parse_ini_file)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(parse_ini_string, arginfo_parse_ini_string)
+	ZEND_RAW_FENTRY("parse_ini_string", zif_parse_ini_string, arginfo_parse_ini_string, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if ZEND_DEBUG
 	ZEND_FE(config_get_hash, arginfo_config_get_hash)
 #endif
@@ -3097,10 +3097,10 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(sys_getloadavg, arginfo_sys_getloadavg)
 #endif
 	ZEND_FE(get_browser, arginfo_get_browser)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(crc32, arginfo_crc32)
+	ZEND_RAW_FENTRY("crc32", zif_crc32, arginfo_crc32, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(crypt, arginfo_crypt)
 #if defined(HAVE_STRPTIME)
-	ZEND_DEP_FE(strptime, arginfo_strptime)
+	ZEND_RAW_FENTRY("strptime", zif_strptime, arginfo_strptime, ZEND_ACC_DEPRECATED, NULL, NULL)
 #endif
 #if defined(HAVE_GETHOSTNAME)
 	ZEND_FE(gethostname, arginfo_gethostname)
@@ -3112,7 +3112,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(dns_check_record, arginfo_dns_check_record)
 #endif
 #if (defined(PHP_WIN32) || defined(HAVE_DNS_SEARCH_FUNC))
-	ZEND_FALIAS(checkdnsrr, dns_check_record, arginfo_checkdnsrr)
+	ZEND_RAW_FENTRY("checkdnsrr", zif_dns_check_record, arginfo_checkdnsrr, 0, NULL, NULL)
 #endif
 #if (defined(PHP_WIN32) || defined(HAVE_DNS_SEARCH_FUNC))
 	ZEND_FE(dns_get_record, arginfo_dns_get_record)
@@ -3121,7 +3121,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(dns_get_mx, arginfo_dns_get_mx)
 #endif
 #if (defined(PHP_WIN32) || defined(HAVE_DNS_SEARCH_FUNC))
-	ZEND_FALIAS(getmxrr, dns_get_mx, arginfo_getmxrr)
+	ZEND_RAW_FENTRY("getmxrr", zif_dns_get_mx, arginfo_getmxrr, 0, NULL, NULL)
 #endif
 #if (defined(PHP_WIN32) || HAVE_GETIFADDRS || defined(__PASE__))
 	ZEND_FE(net_get_interfaces, arginfo_net_get_interfaces)
@@ -3164,82 +3164,82 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(htmlentities, arginfo_htmlentities)
 	ZEND_FE(get_html_translation_table, arginfo_get_html_translation_table)
 	ZEND_FE(assert, arginfo_assert)
-	ZEND_DEP_FE(assert_options, arginfo_assert_options)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(bin2hex, arginfo_bin2hex)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(hex2bin, arginfo_hex2bin)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strspn, arginfo_strspn)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strcspn, arginfo_strcspn)
+	ZEND_RAW_FENTRY("assert_options", zif_assert_options, arginfo_assert_options, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("bin2hex", zif_bin2hex, arginfo_bin2hex, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("hex2bin", zif_hex2bin, arginfo_hex2bin, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strspn", zif_strspn, arginfo_strspn, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strcspn", zif_strcspn, arginfo_strcspn, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if defined(HAVE_NL_LANGINFO)
 	ZEND_FE(nl_langinfo, arginfo_nl_langinfo)
 #endif
 	ZEND_FE(strcoll, arginfo_strcoll)
-	ZEND_FRAMELESS_FE(trim, arginfo_trim, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_trim)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(rtrim, arginfo_rtrim)
-	ZEND_FALIAS(chop, rtrim, arginfo_chop)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(ltrim, arginfo_ltrim)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(wordwrap, arginfo_wordwrap)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(explode, arginfo_explode)
-	ZEND_FRAMELESS_FE(implode, arginfo_implode, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_implode)
-	ZEND_FALIAS(join, implode, arginfo_join)
+	ZEND_RAW_FENTRY("trim", zif_trim, arginfo_trim, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_trim, NULL)
+	ZEND_RAW_FENTRY("rtrim", zif_rtrim, arginfo_rtrim, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("chop", zif_rtrim, arginfo_chop, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("ltrim", zif_ltrim, arginfo_ltrim, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("wordwrap", zif_wordwrap, arginfo_wordwrap, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("explode", zif_explode, arginfo_explode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("implode", zif_implode, arginfo_implode, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_implode, NULL)
+	ZEND_RAW_FENTRY("join", zif_implode, arginfo_join, 0, NULL, NULL)
 	ZEND_FE(strtok, arginfo_strtok)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strtoupper, arginfo_strtoupper)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strtolower, arginfo_strtolower)
+	ZEND_RAW_FENTRY("strtoupper", zif_strtoupper, arginfo_strtoupper, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strtolower", zif_strtolower, arginfo_strtolower, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(str_increment, arginfo_str_increment)
 	ZEND_FE(str_decrement, arginfo_str_decrement)
 	ZEND_FE(basename, arginfo_basename)
-	ZEND_FRAMELESS_FE(dirname, arginfo_dirname, 0, frameless_function_infos_dirname)
+	ZEND_RAW_FENTRY("dirname", zif_dirname, arginfo_dirname, 0, frameless_function_infos_dirname, NULL)
 	ZEND_FE(pathinfo, arginfo_pathinfo)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(stristr, arginfo_stristr)
-	ZEND_FRAMELESS_FE(strstr, arginfo_strstr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strstr)
-	ZEND_FALIAS(strchr, strstr, arginfo_strchr)
-	ZEND_FRAMELESS_FE(strpos, arginfo_strpos, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strpos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(stripos, arginfo_stripos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strrpos, arginfo_strrpos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strripos, arginfo_strripos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strrchr, arginfo_strrchr)
-	ZEND_FRAMELESS_FE(str_contains, arginfo_str_contains, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_contains)
-	ZEND_FRAMELESS_FE(str_starts_with, arginfo_str_starts_with, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_starts_with)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(str_ends_with, arginfo_str_ends_with)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(chunk_split, arginfo_chunk_split)
-	ZEND_FRAMELESS_FE(substr, arginfo_substr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_substr)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(substr_replace, arginfo_substr_replace)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(quotemeta, arginfo_quotemeta)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(ord, arginfo_ord)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(chr, arginfo_chr)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(ucfirst, arginfo_ucfirst)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(lcfirst, arginfo_lcfirst)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(ucwords, arginfo_ucwords)
-	ZEND_FRAMELESS_FE(strtr, arginfo_strtr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strtr)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strrev, arginfo_strrev)
+	ZEND_RAW_FENTRY("stristr", zif_stristr, arginfo_stristr, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strstr", zif_strstr, arginfo_strstr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strstr, NULL)
+	ZEND_RAW_FENTRY("strchr", zif_strstr, arginfo_strchr, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("strpos", zif_strpos, arginfo_strpos, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strpos, NULL)
+	ZEND_RAW_FENTRY("stripos", zif_stripos, arginfo_stripos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strrpos", zif_strrpos, arginfo_strrpos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strripos", zif_strripos, arginfo_strripos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strrchr", zif_strrchr, arginfo_strrchr, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("str_contains", zif_str_contains, arginfo_str_contains, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_contains, NULL)
+	ZEND_RAW_FENTRY("str_starts_with", zif_str_starts_with, arginfo_str_starts_with, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_starts_with, NULL)
+	ZEND_RAW_FENTRY("str_ends_with", zif_str_ends_with, arginfo_str_ends_with, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("chunk_split", zif_chunk_split, arginfo_chunk_split, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("substr", zif_substr, arginfo_substr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_substr, NULL)
+	ZEND_RAW_FENTRY("substr_replace", zif_substr_replace, arginfo_substr_replace, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("quotemeta", zif_quotemeta, arginfo_quotemeta, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("ord", zif_ord, arginfo_ord, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("chr", zif_chr, arginfo_chr, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("ucfirst", zif_ucfirst, arginfo_ucfirst, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("lcfirst", zif_lcfirst, arginfo_lcfirst, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("ucwords", zif_ucwords, arginfo_ucwords, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strtr", zif_strtr, arginfo_strtr, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_strtr, NULL)
+	ZEND_RAW_FENTRY("strrev", zif_strrev, arginfo_strrev, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(similar_text, arginfo_similar_text)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(addcslashes, arginfo_addcslashes)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(addslashes, arginfo_addslashes)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(stripcslashes, arginfo_stripcslashes)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(stripslashes, arginfo_stripslashes)
-	ZEND_FRAMELESS_FE(str_replace, arginfo_str_replace, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_replace)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(str_ireplace, arginfo_str_ireplace)
+	ZEND_RAW_FENTRY("addcslashes", zif_addcslashes, arginfo_addcslashes, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("addslashes", zif_addslashes, arginfo_addslashes, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("stripcslashes", zif_stripcslashes, arginfo_stripcslashes, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("stripslashes", zif_stripslashes, arginfo_stripslashes, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("str_replace", zif_str_replace, arginfo_str_replace, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_str_replace, NULL)
+	ZEND_RAW_FENTRY("str_ireplace", zif_str_ireplace, arginfo_str_ireplace, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(hebrev, arginfo_hebrev)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(nl2br, arginfo_nl2br)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strip_tags, arginfo_strip_tags)
+	ZEND_RAW_FENTRY("nl2br", zif_nl2br, arginfo_nl2br, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strip_tags", zif_strip_tags, arginfo_strip_tags, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(setlocale, arginfo_setlocale)
 	ZEND_FE(parse_str, arginfo_parse_str)
 	ZEND_FE(str_getcsv, arginfo_str_getcsv)
 	ZEND_FE(str_repeat, arginfo_str_repeat)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(count_chars, arginfo_count_chars)
+	ZEND_RAW_FENTRY("count_chars", zif_count_chars, arginfo_count_chars, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(strnatcmp, arginfo_strnatcmp)
 	ZEND_FE(localeconv, arginfo_localeconv)
 	ZEND_FE(strnatcasecmp, arginfo_strnatcasecmp)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(substr_count, arginfo_substr_count)
+	ZEND_RAW_FENTRY("substr_count", zif_substr_count, arginfo_substr_count, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(str_pad, arginfo_str_pad)
 	ZEND_FE(sscanf, arginfo_sscanf)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(str_rot13, arginfo_str_rot13)
+	ZEND_RAW_FENTRY("str_rot13", zif_str_rot13, arginfo_str_rot13, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(str_shuffle, arginfo_str_shuffle)
 	ZEND_FE(str_word_count, arginfo_str_word_count)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(str_split, arginfo_str_split)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strpbrk, arginfo_strpbrk)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(substr_compare, arginfo_substr_compare)
-	ZEND_DEP_FE(utf8_encode, arginfo_utf8_encode)
-	ZEND_DEP_FE(utf8_decode, arginfo_utf8_decode)
+	ZEND_RAW_FENTRY("str_split", zif_str_split, arginfo_str_split, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strpbrk", zif_strpbrk, arginfo_strpbrk, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("substr_compare", zif_substr_compare, arginfo_substr_compare, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("utf8_encode", zif_utf8_encode, arginfo_utf8_encode, ZEND_ACC_DEPRECATED|ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("utf8_decode", zif_utf8_decode, arginfo_utf8_decode, ZEND_ACC_DEPRECATED|ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(opendir, arginfo_opendir)
 	ZEND_FE(dir, arginfo_dir)
 	ZEND_FE(closedir, arginfo_closedir)
@@ -3287,7 +3287,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(fsync, arginfo_fsync)
 	ZEND_FE(fdatasync, arginfo_fdatasync)
 	ZEND_FE(fwrite, arginfo_fwrite)
-	ZEND_FALIAS(fputs, fwrite, arginfo_fputs)
+	ZEND_RAW_FENTRY("fputs", zif_fwrite, arginfo_fputs, 0, NULL, NULL)
 	ZEND_FE(mkdir, arginfo_mkdir)
 	ZEND_FE(rename, arginfo_rename)
 	ZEND_FE(copy, arginfo_copy)
@@ -3315,7 +3315,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(filetype, arginfo_filetype)
 	ZEND_FE(file_exists, arginfo_file_exists)
 	ZEND_FE(is_writable, arginfo_is_writable)
-	ZEND_FALIAS(is_writeable, is_writable, arginfo_is_writeable)
+	ZEND_RAW_FENTRY("is_writeable", zif_is_writable, arginfo_is_writeable, 0, NULL, NULL)
 	ZEND_FE(is_readable, arginfo_is_readable)
 	ZEND_FE(is_executable, arginfo_is_executable)
 	ZEND_FE(is_file, arginfo_is_file)
@@ -3338,7 +3338,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(clearstatcache, arginfo_clearstatcache)
 	ZEND_FE(disk_total_space, arginfo_disk_total_space)
 	ZEND_FE(disk_free_space, arginfo_disk_free_space)
-	ZEND_FALIAS(diskfreespace, disk_free_space, arginfo_diskfreespace)
+	ZEND_RAW_FENTRY("diskfreespace", zif_disk_free_space, arginfo_diskfreespace, 0, NULL, NULL)
 	ZEND_FE(realpath_cache_get, arginfo_realpath_cache_get)
 	ZEND_FE(realpath_cache_size, arginfo_realpath_cache_size)
 	ZEND_FE(sprintf, arginfo_sprintf)
@@ -3351,15 +3351,15 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(pfsockopen, arginfo_pfsockopen)
 	ZEND_FE(http_build_query, arginfo_http_build_query)
 	ZEND_FE(request_parse_body, arginfo_request_parse_body)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(image_type_to_mime_type, arginfo_image_type_to_mime_type)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(image_type_to_extension, arginfo_image_type_to_extension)
+	ZEND_RAW_FENTRY("image_type_to_mime_type", zif_image_type_to_mime_type, arginfo_image_type_to_mime_type, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("image_type_to_extension", zif_image_type_to_extension, arginfo_image_type_to_extension, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(getimagesize, arginfo_getimagesize)
 	ZEND_FE(getimagesizefromstring, arginfo_getimagesizefromstring)
 	ZEND_FE(phpinfo, arginfo_phpinfo)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(phpversion, arginfo_phpversion)
+	ZEND_RAW_FENTRY("phpversion", zif_phpversion, arginfo_phpversion, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(phpcredits, arginfo_phpcredits)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(php_sapi_name, arginfo_php_sapi_name)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(php_uname, arginfo_php_uname)
+	ZEND_RAW_FENTRY("php_sapi_name", zif_php_sapi_name, arginfo_php_sapi_name, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("php_uname", zif_php_uname, arginfo_php_uname, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(php_ini_scanned_files, arginfo_php_ini_scanned_files)
 	ZEND_FE(php_ini_loaded_file, arginfo_php_ini_loaded_file)
 	ZEND_FE(iptcembed, arginfo_iptcembed)
@@ -3378,48 +3378,48 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(link, arginfo_link)
 #endif
 	ZEND_FE(mail, arginfo_mail)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(abs, arginfo_abs)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(ceil, arginfo_ceil)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(floor, arginfo_floor)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(round, arginfo_round)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(sin, arginfo_sin)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(cos, arginfo_cos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(tan, arginfo_tan)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(asin, arginfo_asin)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(acos, arginfo_acos)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(atan, arginfo_atan)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(atanh, arginfo_atanh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(atan2, arginfo_atan2)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(sinh, arginfo_sinh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(cosh, arginfo_cosh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(tanh, arginfo_tanh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(asinh, arginfo_asinh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(acosh, arginfo_acosh)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(expm1, arginfo_expm1)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(log1p, arginfo_log1p)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(pi, arginfo_pi)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_finite, arginfo_is_finite)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_nan, arginfo_is_nan)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(intdiv, arginfo_intdiv)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_infinite, arginfo_is_infinite)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(pow, arginfo_pow)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(exp, arginfo_exp)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(log, arginfo_log)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(log10, arginfo_log10)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(sqrt, arginfo_sqrt)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(hypot, arginfo_hypot)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(deg2rad, arginfo_deg2rad)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(rad2deg, arginfo_rad2deg)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(bindec, arginfo_bindec)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(hexdec, arginfo_hexdec)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(octdec, arginfo_octdec)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(decbin, arginfo_decbin)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(decoct, arginfo_decoct)
-	ZEND_FRAMELESS_FE(dechex, arginfo_dechex, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_dechex)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(base_convert, arginfo_base_convert)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(number_format, arginfo_number_format)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(fmod, arginfo_fmod)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(fdiv, arginfo_fdiv)
+	ZEND_RAW_FENTRY("abs", zif_abs, arginfo_abs, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("ceil", zif_ceil, arginfo_ceil, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("floor", zif_floor, arginfo_floor, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("round", zif_round, arginfo_round, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("sin", zif_sin, arginfo_sin, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("cos", zif_cos, arginfo_cos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("tan", zif_tan, arginfo_tan, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("asin", zif_asin, arginfo_asin, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("acos", zif_acos, arginfo_acos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("atan", zif_atan, arginfo_atan, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("atanh", zif_atanh, arginfo_atanh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("atan2", zif_atan2, arginfo_atan2, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("sinh", zif_sinh, arginfo_sinh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("cosh", zif_cosh, arginfo_cosh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("tanh", zif_tanh, arginfo_tanh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("asinh", zif_asinh, arginfo_asinh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("acosh", zif_acosh, arginfo_acosh, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("expm1", zif_expm1, arginfo_expm1, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("log1p", zif_log1p, arginfo_log1p, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("pi", zif_pi, arginfo_pi, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_finite", zif_is_finite, arginfo_is_finite, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_nan", zif_is_nan, arginfo_is_nan, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("intdiv", zif_intdiv, arginfo_intdiv, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_infinite", zif_is_infinite, arginfo_is_infinite, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("pow", zif_pow, arginfo_pow, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("exp", zif_exp, arginfo_exp, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("log", zif_log, arginfo_log, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("log10", zif_log10, arginfo_log10, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("sqrt", zif_sqrt, arginfo_sqrt, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("hypot", zif_hypot, arginfo_hypot, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("deg2rad", zif_deg2rad, arginfo_deg2rad, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("rad2deg", zif_rad2deg, arginfo_rad2deg, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("bindec", zif_bindec, arginfo_bindec, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("hexdec", zif_hexdec, arginfo_hexdec, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("octdec", zif_octdec, arginfo_octdec, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("decbin", zif_decbin, arginfo_decbin, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("decoct", zif_decoct, arginfo_decoct, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("dechex", zif_dechex, arginfo_dechex, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_dechex, NULL)
+	ZEND_RAW_FENTRY("base_convert", zif_base_convert, arginfo_base_convert, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("number_format", zif_number_format, arginfo_number_format, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("fmod", zif_fmod, arginfo_fmod, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("fdiv", zif_fdiv, arginfo_fdiv, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if defined(HAVE_GETTIMEOFDAY)
 	ZEND_FE(microtime, arginfo_microtime)
 #endif
@@ -3429,13 +3429,13 @@ static const zend_function_entry ext_functions[] = {
 #if defined(HAVE_GETRUSAGE)
 	ZEND_FE(getrusage, arginfo_getrusage)
 #endif
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(pack, arginfo_pack)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(unpack, arginfo_unpack)
+	ZEND_RAW_FENTRY("pack", zif_pack, arginfo_pack, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("unpack", zif_unpack, arginfo_unpack, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(password_get_info, arginfo_password_get_info)
 	ZEND_FE(password_hash, arginfo_password_hash)
 	ZEND_FE(password_needs_rehash, arginfo_password_needs_rehash)
 	ZEND_FE(password_verify, arginfo_password_verify)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(password_algos, arginfo_password_algos)
+	ZEND_RAW_FENTRY("password_algos", zif_password_algos, arginfo_password_algos, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if defined(PHP_CAN_SUPPORT_PROC_OPEN)
 	ZEND_FE(proc_open, arginfo_proc_open)
 #endif
@@ -3448,8 +3448,8 @@ static const zend_function_entry ext_functions[] = {
 #if defined(PHP_CAN_SUPPORT_PROC_OPEN)
 	ZEND_FE(proc_get_status, arginfo_proc_get_status)
 #endif
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(quoted_printable_decode, arginfo_quoted_printable_decode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(quoted_printable_encode, arginfo_quoted_printable_encode)
+	ZEND_RAW_FENTRY("quoted_printable_decode", zif_quoted_printable_decode, arginfo_quoted_printable_decode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("quoted_printable_encode", zif_quoted_printable_encode, arginfo_quoted_printable_encode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(soundex, arginfo_soundex)
 	ZEND_FE(stream_select, arginfo_stream_select)
 	ZEND_FE(stream_context_create, arginfo_stream_context_create)
@@ -3480,12 +3480,12 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(stream_get_contents, arginfo_stream_get_contents)
 	ZEND_FE(stream_supports_lock, arginfo_stream_supports_lock)
 	ZEND_FE(stream_set_write_buffer, arginfo_stream_set_write_buffer)
-	ZEND_FALIAS(set_file_buffer, stream_set_write_buffer, arginfo_set_file_buffer)
+	ZEND_RAW_FENTRY("set_file_buffer", zif_stream_set_write_buffer, arginfo_set_file_buffer, 0, NULL, NULL)
 	ZEND_FE(stream_set_read_buffer, arginfo_stream_set_read_buffer)
 	ZEND_FE(stream_set_blocking, arginfo_stream_set_blocking)
-	ZEND_FALIAS(socket_set_blocking, stream_set_blocking, arginfo_socket_set_blocking)
+	ZEND_RAW_FENTRY("socket_set_blocking", zif_stream_set_blocking, arginfo_socket_set_blocking, 0, NULL, NULL)
 	ZEND_FE(stream_get_meta_data, arginfo_stream_get_meta_data)
-	ZEND_FALIAS(socket_get_status, stream_get_meta_data, arginfo_socket_get_status)
+	ZEND_RAW_FENTRY("socket_get_status", zif_stream_get_meta_data, arginfo_socket_get_status, 0, NULL, NULL)
 	ZEND_FE(stream_get_line, arginfo_stream_get_line)
 	ZEND_FE(stream_resolve_include_path, arginfo_stream_resolve_include_path)
 	ZEND_FE(stream_get_wrappers, arginfo_stream_get_wrappers)
@@ -3500,40 +3500,40 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(stream_set_timeout, arginfo_stream_set_timeout)
 #endif
 #if (defined(HAVE_SYS_TIME_H) || defined(PHP_WIN32))
-	ZEND_FALIAS(socket_set_timeout, stream_set_timeout, arginfo_socket_set_timeout)
+	ZEND_RAW_FENTRY("socket_set_timeout", zif_stream_set_timeout, arginfo_socket_set_timeout, 0, NULL, NULL)
 #endif
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(gettype, arginfo_gettype)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(get_debug_type, arginfo_get_debug_type)
+	ZEND_RAW_FENTRY("gettype", zif_gettype, arginfo_gettype, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("get_debug_type", zif_get_debug_type, arginfo_get_debug_type, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(settype, arginfo_settype)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(intval, arginfo_intval)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(floatval, arginfo_floatval)
-	ZEND_FALIAS(doubleval, floatval, arginfo_doubleval)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(boolval, arginfo_boolval)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(strval, arginfo_strval)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_null, arginfo_is_null)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_resource, arginfo_is_resource)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_bool, arginfo_is_bool)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_int, arginfo_is_int)
-	ZEND_FALIAS(is_integer, is_int, arginfo_is_integer)
-	ZEND_FALIAS(is_long, is_int, arginfo_is_long)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_float, arginfo_is_float)
-	ZEND_FALIAS(is_double, is_float, arginfo_is_double)
-	ZEND_FRAMELESS_FE(is_numeric, arginfo_is_numeric, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_is_numeric)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_string, arginfo_is_string)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_array, arginfo_is_array)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_object, arginfo_is_object)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_scalar, arginfo_is_scalar)
+	ZEND_RAW_FENTRY("intval", zif_intval, arginfo_intval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("floatval", zif_floatval, arginfo_floatval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("doubleval", zif_floatval, arginfo_doubleval, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("boolval", zif_boolval, arginfo_boolval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("strval", zif_strval, arginfo_strval, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_null", zif_is_null, arginfo_is_null, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_resource", zif_is_resource, arginfo_is_resource, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_bool", zif_is_bool, arginfo_is_bool, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_int", zif_is_int, arginfo_is_int, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_integer", zif_is_int, arginfo_is_integer, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("is_long", zif_is_int, arginfo_is_long, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("is_float", zif_is_float, arginfo_is_float, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_double", zif_is_float, arginfo_is_double, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("is_numeric", zif_is_numeric, arginfo_is_numeric, ZEND_ACC_COMPILE_TIME_EVAL, frameless_function_infos_is_numeric, NULL)
+	ZEND_RAW_FENTRY("is_string", zif_is_string, arginfo_is_string, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_array", zif_is_array, arginfo_is_array, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_object", zif_is_object, arginfo_is_object, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_scalar", zif_is_scalar, arginfo_is_scalar, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(is_callable, arginfo_is_callable)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_iterable, arginfo_is_iterable)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(is_countable, arginfo_is_countable)
+	ZEND_RAW_FENTRY("is_iterable", zif_is_iterable, arginfo_is_iterable, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("is_countable", zif_is_countable, arginfo_is_countable, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if defined(HAVE_GETTIMEOFDAY)
 	ZEND_FE(uniqid, arginfo_uniqid)
 #endif
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(parse_url, arginfo_parse_url)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(urlencode, arginfo_urlencode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(urldecode, arginfo_urldecode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(rawurlencode, arginfo_rawurlencode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(rawurldecode, arginfo_rawurldecode)
+	ZEND_RAW_FENTRY("parse_url", zif_parse_url, arginfo_parse_url, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("urlencode", zif_urlencode, arginfo_urlencode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("urldecode", zif_urldecode, arginfo_urldecode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("rawurlencode", zif_rawurlencode, arginfo_rawurlencode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("rawurldecode", zif_rawurldecode, arginfo_rawurldecode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(get_headers, arginfo_get_headers)
 	ZEND_FE(stream_bucket_make_writeable, arginfo_stream_bucket_make_writeable)
 	ZEND_FE(stream_bucket_prepend, arginfo_stream_bucket_prepend)
@@ -3541,17 +3541,17 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(stream_bucket_new, arginfo_stream_bucket_new)
 	ZEND_FE(stream_get_filters, arginfo_stream_get_filters)
 	ZEND_FE(stream_filter_register, arginfo_stream_filter_register)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(convert_uuencode, arginfo_convert_uuencode)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(convert_uudecode, arginfo_convert_uudecode)
+	ZEND_RAW_FENTRY("convert_uuencode", zif_convert_uuencode, arginfo_convert_uuencode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
+	ZEND_RAW_FENTRY("convert_uudecode", zif_convert_uudecode, arginfo_convert_uudecode, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(var_dump, arginfo_var_dump)
 	ZEND_FE(var_export, arginfo_var_export)
 	ZEND_FE(debug_zval_dump, arginfo_debug_zval_dump)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(serialize, arginfo_serialize)
+	ZEND_RAW_FENTRY("serialize", zif_serialize, arginfo_serialize, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 	ZEND_FE(unserialize, arginfo_unserialize)
 	ZEND_FE(memory_get_usage, arginfo_memory_get_usage)
 	ZEND_FE(memory_get_peak_usage, arginfo_memory_get_peak_usage)
 	ZEND_FE(memory_reset_peak_usage, arginfo_memory_reset_peak_usage)
-	ZEND_SUPPORTS_COMPILE_TIME_EVAL_FE(version_compare, arginfo_version_compare)
+	ZEND_RAW_FENTRY("version_compare", zif_version_compare, arginfo_version_compare, ZEND_ACC_COMPILE_TIME_EVAL, NULL, NULL)
 #if defined(PHP_WIN32)
 	ZEND_FE(sapi_windows_cp_set, arginfo_sapi_windows_cp_set)
 #endif
diff --git a/ext/standard/dir_arginfo.h b/ext/standard/dir_arginfo.h
index 363ab4fa3e6ed..6ab700254dbd4 100644
--- a/ext/standard/dir_arginfo.h
+++ b/ext/standard/dir_arginfo.h
@@ -14,9 +14,9 @@ ZEND_FUNCTION(rewinddir);
 ZEND_FUNCTION(readdir);
 
 static const zend_function_entry class_Directory_methods[] = {
-	ZEND_ME_MAPPING(close, closedir, arginfo_class_Directory_close, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(rewind, rewinddir, arginfo_class_Directory_rewind, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(read, readdir, arginfo_class_Directory_read, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("close", zif_closedir, arginfo_class_Directory_close, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("rewind", zif_rewinddir, arginfo_class_Directory_rewind, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("read", zif_readdir, arginfo_class_Directory_read, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/tidy/tidy_arginfo.h b/ext/tidy/tidy_arginfo.h
index 8a2774a7b71e0..61aa0687df4f3 100644
--- a/ext/tidy/tidy_arginfo.h
+++ b/ext/tidy/tidy_arginfo.h
@@ -255,26 +255,26 @@ static const zend_function_entry ext_functions[] = {
 
 static const zend_function_entry class_tidy_methods[] = {
 	ZEND_ME(tidy, __construct, arginfo_class_tidy___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getOpt, tidy_getopt, arginfo_class_tidy_getOpt, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(cleanRepair, tidy_clean_repair, arginfo_class_tidy_cleanRepair, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getOpt", zif_tidy_getopt, arginfo_class_tidy_getOpt, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("cleanRepair", zif_tidy_clean_repair, arginfo_class_tidy_cleanRepair, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_ME(tidy, parseFile, arginfo_class_tidy_parseFile, ZEND_ACC_PUBLIC)
 	ZEND_ME(tidy, parseString, arginfo_class_tidy_parseString, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(repairString, tidy_repair_string, arginfo_class_tidy_repairString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(repairFile, tidy_repair_file, arginfo_class_tidy_repairFile, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
-	ZEND_ME_MAPPING(diagnose, tidy_diagnose, arginfo_class_tidy_diagnose, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getRelease, tidy_get_release, arginfo_class_tidy_getRelease, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getConfig, tidy_get_config, arginfo_class_tidy_getConfig, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getStatus, tidy_get_status, arginfo_class_tidy_getStatus, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(getHtmlVer, tidy_get_html_ver, arginfo_class_tidy_getHtmlVer, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("repairString", zif_tidy_repair_string, arginfo_class_tidy_repairString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("repairFile", zif_tidy_repair_file, arginfo_class_tidy_repairFile, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, NULL, NULL)
+	ZEND_RAW_FENTRY("diagnose", zif_tidy_diagnose, arginfo_class_tidy_diagnose, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getRelease", zif_tidy_get_release, arginfo_class_tidy_getRelease, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getConfig", zif_tidy_get_config, arginfo_class_tidy_getConfig, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getStatus", zif_tidy_get_status, arginfo_class_tidy_getStatus, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("getHtmlVer", zif_tidy_get_html_ver, arginfo_class_tidy_getHtmlVer, ZEND_ACC_PUBLIC, NULL, NULL)
 #if defined(HAVE_TIDYOPTGETDOC)
-	ZEND_ME_MAPPING(getOptDoc, tidy_get_opt_doc, arginfo_class_tidy_getOptDoc, ZEND_ACC_PUBLIC)
-#endif
-	ZEND_ME_MAPPING(isXhtml, tidy_is_xhtml, arginfo_class_tidy_isXhtml, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(isXml, tidy_is_xml, arginfo_class_tidy_isXml, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(root, tidy_get_root, arginfo_class_tidy_root, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(head, tidy_get_head, arginfo_class_tidy_head, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(html, tidy_get_html, arginfo_class_tidy_html, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(body, tidy_get_body, arginfo_class_tidy_body, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("getOptDoc", zif_tidy_get_opt_doc, arginfo_class_tidy_getOptDoc, ZEND_ACC_PUBLIC, NULL, NULL)
+#endif
+	ZEND_RAW_FENTRY("isXhtml", zif_tidy_is_xhtml, arginfo_class_tidy_isXhtml, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("isXml", zif_tidy_is_xml, arginfo_class_tidy_isXml, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("root", zif_tidy_get_root, arginfo_class_tidy_root, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("head", zif_tidy_get_head, arginfo_class_tidy_head, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("html", zif_tidy_get_html, arginfo_class_tidy_html, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("body", zif_tidy_get_body, arginfo_class_tidy_body, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/xmlwriter/php_xmlwriter_arginfo.h b/ext/xmlwriter/php_xmlwriter_arginfo.h
index bafb76d40389d..cfa558bd3dc6d 100644
--- a/ext/xmlwriter/php_xmlwriter_arginfo.h
+++ b/ext/xmlwriter/php_xmlwriter_arginfo.h
@@ -417,48 +417,48 @@ static const zend_function_entry ext_functions[] = {
 };
 
 static const zend_function_entry class_XMLWriter_methods[] = {
-	ZEND_ME_MAPPING(openUri, xmlwriter_open_uri, arginfo_class_XMLWriter_openUri, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(openMemory, xmlwriter_open_memory, arginfo_class_XMLWriter_openMemory, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setIndent, xmlwriter_set_indent, arginfo_class_XMLWriter_setIndent, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(setIndentString, xmlwriter_set_indent_string, arginfo_class_XMLWriter_setIndentString, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startComment, xmlwriter_start_comment, arginfo_class_XMLWriter_startComment, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endComment, xmlwriter_end_comment, arginfo_class_XMLWriter_endComment, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startAttribute, xmlwriter_start_attribute, arginfo_class_XMLWriter_startAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endAttribute, xmlwriter_end_attribute, arginfo_class_XMLWriter_endAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeAttribute, xmlwriter_write_attribute, arginfo_class_XMLWriter_writeAttribute, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startAttributeNs, xmlwriter_start_attribute_ns, arginfo_class_XMLWriter_startAttributeNs, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeAttributeNs, xmlwriter_write_attribute_ns, arginfo_class_XMLWriter_writeAttributeNs, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startElement, xmlwriter_start_element, arginfo_class_XMLWriter_startElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endElement, xmlwriter_end_element, arginfo_class_XMLWriter_endElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(fullEndElement, xmlwriter_full_end_element, arginfo_class_XMLWriter_fullEndElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startElementNs, xmlwriter_start_element_ns, arginfo_class_XMLWriter_startElementNs, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeElement, xmlwriter_write_element, arginfo_class_XMLWriter_writeElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeElementNs, xmlwriter_write_element_ns, arginfo_class_XMLWriter_writeElementNs, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startPi, xmlwriter_start_pi, arginfo_class_XMLWriter_startPi, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endPi, xmlwriter_end_pi, arginfo_class_XMLWriter_endPi, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writePi, xmlwriter_write_pi, arginfo_class_XMLWriter_writePi, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startCdata, xmlwriter_start_cdata, arginfo_class_XMLWriter_startCdata, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endCdata, xmlwriter_end_cdata, arginfo_class_XMLWriter_endCdata, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeCdata, xmlwriter_write_cdata, arginfo_class_XMLWriter_writeCdata, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(text, xmlwriter_text, arginfo_class_XMLWriter_text, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeRaw, xmlwriter_write_raw, arginfo_class_XMLWriter_writeRaw, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startDocument, xmlwriter_start_document, arginfo_class_XMLWriter_startDocument, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endDocument, xmlwriter_end_document, arginfo_class_XMLWriter_endDocument, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeComment, xmlwriter_write_comment, arginfo_class_XMLWriter_writeComment, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startDtd, xmlwriter_start_dtd, arginfo_class_XMLWriter_startDtd, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endDtd, xmlwriter_end_dtd, arginfo_class_XMLWriter_endDtd, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeDtd, xmlwriter_write_dtd, arginfo_class_XMLWriter_writeDtd, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startDtdElement, xmlwriter_start_dtd_element, arginfo_class_XMLWriter_startDtdElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endDtdElement, xmlwriter_end_dtd_element, arginfo_class_XMLWriter_endDtdElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeDtdElement, xmlwriter_write_dtd_element, arginfo_class_XMLWriter_writeDtdElement, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startDtdAttlist, xmlwriter_start_dtd_attlist, arginfo_class_XMLWriter_startDtdAttlist, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endDtdAttlist, xmlwriter_end_dtd_attlist, arginfo_class_XMLWriter_endDtdAttlist, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeDtdAttlist, xmlwriter_write_dtd_attlist, arginfo_class_XMLWriter_writeDtdAttlist, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(startDtdEntity, xmlwriter_start_dtd_entity, arginfo_class_XMLWriter_startDtdEntity, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(endDtdEntity, xmlwriter_end_dtd_entity, arginfo_class_XMLWriter_endDtdEntity, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(writeDtdEntity, xmlwriter_write_dtd_entity, arginfo_class_XMLWriter_writeDtdEntity, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(outputMemory, xmlwriter_output_memory, arginfo_class_XMLWriter_outputMemory, ZEND_ACC_PUBLIC)
-	ZEND_ME_MAPPING(flush, xmlwriter_flush, arginfo_class_XMLWriter_flush, ZEND_ACC_PUBLIC)
+	ZEND_RAW_FENTRY("openUri", zif_xmlwriter_open_uri, arginfo_class_XMLWriter_openUri, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("openMemory", zif_xmlwriter_open_memory, arginfo_class_XMLWriter_openMemory, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setIndent", zif_xmlwriter_set_indent, arginfo_class_XMLWriter_setIndent, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("setIndentString", zif_xmlwriter_set_indent_string, arginfo_class_XMLWriter_setIndentString, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startComment", zif_xmlwriter_start_comment, arginfo_class_XMLWriter_startComment, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endComment", zif_xmlwriter_end_comment, arginfo_class_XMLWriter_endComment, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startAttribute", zif_xmlwriter_start_attribute, arginfo_class_XMLWriter_startAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endAttribute", zif_xmlwriter_end_attribute, arginfo_class_XMLWriter_endAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeAttribute", zif_xmlwriter_write_attribute, arginfo_class_XMLWriter_writeAttribute, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startAttributeNs", zif_xmlwriter_start_attribute_ns, arginfo_class_XMLWriter_startAttributeNs, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeAttributeNs", zif_xmlwriter_write_attribute_ns, arginfo_class_XMLWriter_writeAttributeNs, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startElement", zif_xmlwriter_start_element, arginfo_class_XMLWriter_startElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endElement", zif_xmlwriter_end_element, arginfo_class_XMLWriter_endElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("fullEndElement", zif_xmlwriter_full_end_element, arginfo_class_XMLWriter_fullEndElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startElementNs", zif_xmlwriter_start_element_ns, arginfo_class_XMLWriter_startElementNs, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeElement", zif_xmlwriter_write_element, arginfo_class_XMLWriter_writeElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeElementNs", zif_xmlwriter_write_element_ns, arginfo_class_XMLWriter_writeElementNs, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startPi", zif_xmlwriter_start_pi, arginfo_class_XMLWriter_startPi, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endPi", zif_xmlwriter_end_pi, arginfo_class_XMLWriter_endPi, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writePi", zif_xmlwriter_write_pi, arginfo_class_XMLWriter_writePi, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startCdata", zif_xmlwriter_start_cdata, arginfo_class_XMLWriter_startCdata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endCdata", zif_xmlwriter_end_cdata, arginfo_class_XMLWriter_endCdata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeCdata", zif_xmlwriter_write_cdata, arginfo_class_XMLWriter_writeCdata, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("text", zif_xmlwriter_text, arginfo_class_XMLWriter_text, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeRaw", zif_xmlwriter_write_raw, arginfo_class_XMLWriter_writeRaw, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startDocument", zif_xmlwriter_start_document, arginfo_class_XMLWriter_startDocument, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endDocument", zif_xmlwriter_end_document, arginfo_class_XMLWriter_endDocument, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeComment", zif_xmlwriter_write_comment, arginfo_class_XMLWriter_writeComment, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startDtd", zif_xmlwriter_start_dtd, arginfo_class_XMLWriter_startDtd, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endDtd", zif_xmlwriter_end_dtd, arginfo_class_XMLWriter_endDtd, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeDtd", zif_xmlwriter_write_dtd, arginfo_class_XMLWriter_writeDtd, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startDtdElement", zif_xmlwriter_start_dtd_element, arginfo_class_XMLWriter_startDtdElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endDtdElement", zif_xmlwriter_end_dtd_element, arginfo_class_XMLWriter_endDtdElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeDtdElement", zif_xmlwriter_write_dtd_element, arginfo_class_XMLWriter_writeDtdElement, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startDtdAttlist", zif_xmlwriter_start_dtd_attlist, arginfo_class_XMLWriter_startDtdAttlist, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endDtdAttlist", zif_xmlwriter_end_dtd_attlist, arginfo_class_XMLWriter_endDtdAttlist, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeDtdAttlist", zif_xmlwriter_write_dtd_attlist, arginfo_class_XMLWriter_writeDtdAttlist, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("startDtdEntity", zif_xmlwriter_start_dtd_entity, arginfo_class_XMLWriter_startDtdEntity, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("endDtdEntity", zif_xmlwriter_end_dtd_entity, arginfo_class_XMLWriter_endDtdEntity, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("writeDtdEntity", zif_xmlwriter_write_dtd_entity, arginfo_class_XMLWriter_writeDtdEntity, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("outputMemory", zif_xmlwriter_output_memory, arginfo_class_XMLWriter_outputMemory, ZEND_ACC_PUBLIC, NULL, NULL)
+	ZEND_RAW_FENTRY("flush", zif_xmlwriter_flush, arginfo_class_XMLWriter_flush, ZEND_ACC_PUBLIC, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c
index ba91328596926..390f3b054ca03 100644
--- a/ext/zend_test/test.c
+++ b/ext/zend_test/test.c
@@ -94,6 +94,8 @@ static ZEND_FUNCTION(zend_test_array_return)
 static ZEND_FUNCTION(zend_test_nullable_array_return)
 {
 	ZEND_PARSE_PARAMETERS_NONE();
+
+	RETURN_NULL();
 }
 
 static ZEND_FUNCTION(zend_test_void_return)
@@ -748,22 +750,23 @@ static zend_object *zend_test_class_new(zend_class_entry *class_type)
 static zend_function *zend_test_class_method_get(zend_object **object, zend_string *name, const zval *key)
 {
 	if (zend_string_equals_literal_ci(name, "test")) {
-	    zend_internal_function *fptr;
+		zend_internal_function *fptr;
 
-	    if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
-		    fptr = (zend_internal_function *) &EG(trampoline);
-	    } else {
-		    fptr = emalloc(sizeof(zend_internal_function));
+		if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
+			fptr = (zend_internal_function *) &EG(trampoline);
+		} else {
+			fptr = emalloc(sizeof(zend_internal_function));
 	    }
-	    memset(fptr, 0, sizeof(zend_internal_function));
-	    fptr->type = ZEND_INTERNAL_FUNCTION;
-	    fptr->num_args = 1;
-	    fptr->scope = (*object)->ce;
-	    fptr->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
-	    fptr->function_name = zend_string_copy(name);
-	    fptr->handler = ZEND_FN(zend_test_func);
-
-	    return (zend_function*)fptr;
+		memset(fptr, 0, sizeof(zend_internal_function));
+		fptr->type = ZEND_INTERNAL_FUNCTION;
+		fptr->num_args = 1;
+		fptr->scope = (*object)->ce;
+		fptr->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
+		fptr->function_name = zend_string_copy(name);
+		fptr->handler = ZEND_FN(zend_test_func);
+		fptr->doc_comment = NULL;
+
+		return (zend_function*)fptr;
 	}
 	return zend_std_get_method(object, name, key);
 }
@@ -785,6 +788,7 @@ static zend_function *zend_test_class_static_method_get(zend_class_entry *ce, ze
 		fptr->fn_flags = ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_STATIC;
 		fptr->function_name = zend_string_copy(name);
 		fptr->handler = ZEND_FN(zend_test_func);
+		fptr->doc_comment = NULL;
 
 		return (zend_function*)fptr;
 	}
diff --git a/ext/zend_test/test.stub.php b/ext/zend_test/test.stub.php
index 0f816950ca765..1bfb08251f8a3 100644
--- a/ext/zend_test/test.stub.php
+++ b/ext/zend_test/test.stub.php
@@ -20,6 +20,11 @@
     interface _ZendTestInterface
     {
         /** @var int */
+        /** @genstubs-expose-comment-block
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.2
+         */
         public const DUMMY = 0;
     }
 
@@ -105,8 +110,18 @@ final class ZendTestParameterAttribute {
         public function __construct(string $parameter) {}
     }
 
+    /** @genstubs-expose-comment-block
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.1
+     */
     #[Attribute(Attribute::TARGET_PROPERTY)]
     final class ZendTestPropertyAttribute {
+        /** @genstubs-expose-comment-block
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.4
+         */
         public string $parameter;
 
         public function __construct(string $parameter) {}
@@ -161,6 +176,15 @@ enum ZendTestIntEnum: int {
 
     function zend_test_array_return(): array {}
 
+    /** @genstubs-expose-comment-block
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.3
+     */
+     /**
+     * @internal
+     * @compile-time-eval
+     */
     function zend_test_nullable_array_return(): null|array {}
 
     function zend_test_void_return(): void {}
diff --git a/ext/zend_test/test_arginfo.h b/ext/zend_test/test_arginfo.h
index 44b27f1bc06fa..736dcfd8b2549 100644
--- a/ext/zend_test/test_arginfo.h
+++ b/ext/zend_test/test_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 39a14fb061199171b0a0a08b821dabcba516ccf5 */
+ * Stub hash: dd3f852ea9f8e3a356ed226380edf5cc336f8a4e */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_test_array_return, 0, 0, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
@@ -294,12 +294,32 @@ static ZEND_METHOD(ZendTestNS2_ZendSubNS_Foo, method);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(zend_test_array_return, arginfo_zend_test_array_return)
-	ZEND_FE(zend_test_nullable_array_return, arginfo_zend_test_nullable_array_return)
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY("zend_test_nullable_array_return", zif_zend_test_nullable_array_return, arginfo_zend_test_nullable_array_return, ZEND_ACC_COMPILE_TIME_EVAL, NULL, "/**\n     * \"Lorem ipsum\"\n     * @see https://www.php.net\n     * @since 8.3\n     */")
+#else
+#if (PHP_VERSION_ID >= 80200)
+	ZEND_RAW_FENTRY("zend_test_nullable_array_return", zif_zend_test_nullable_array_return, arginfo_zend_test_nullable_array_return, ZEND_ACC_COMPILE_TIME_EVAL)
+#elif (PHP_VERSION_ID >= 80000)
+	ZEND_RAW_FENTRY("zend_test_nullable_array_return", zif_zend_test_nullable_array_return, arginfo_zend_test_nullable_array_return, 0)
+#endif
+#endif
 	ZEND_FE(zend_test_void_return, arginfo_zend_test_void_return)
 	ZEND_FE(zend_test_compile_string, arginfo_zend_test_compile_string)
-	ZEND_DEP_FE(zend_test_deprecated, arginfo_zend_test_deprecated)
-	ZEND_FALIAS(zend_test_aliased, zend_test_void_return, arginfo_zend_test_aliased)
-	ZEND_DEP_FALIAS(zend_test_deprecated_aliased, zend_test_void_return, arginfo_zend_test_deprecated_aliased)
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY("zend_test_deprecated", zif_zend_test_deprecated, arginfo_zend_test_deprecated, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY("zend_test_deprecated", zif_zend_test_deprecated, arginfo_zend_test_deprecated, ZEND_ACC_DEPRECATED)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY("zend_test_aliased", zif_zend_test_void_return, arginfo_zend_test_aliased, 0, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY("zend_test_aliased", zif_zend_test_void_return, arginfo_zend_test_aliased, 0)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY("zend_test_deprecated_aliased", zif_zend_test_void_return, arginfo_zend_test_deprecated_aliased, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY("zend_test_deprecated_aliased", zif_zend_test_void_return, arginfo_zend_test_deprecated_aliased, ZEND_ACC_DEPRECATED)
+#endif
 	ZEND_FE(zend_create_unterminated_string, arginfo_zend_create_unterminated_string)
 	ZEND_FE(zend_terminate_string, arginfo_zend_terminate_string)
 	ZEND_FE(zend_leak_variable, arginfo_zend_leak_variable)
@@ -337,14 +357,46 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(zend_test_override_libxml_global_state, arginfo_zend_test_override_libxml_global_state)
 #endif
 	ZEND_FE(zend_test_is_pcre_bundled, arginfo_zend_test_is_pcre_bundled)
-	ZEND_NS_FALIAS("ZendTestNS2", namespaced_func, ZendTestNS2_namespaced_func, arginfo_ZendTestNS2_namespaced_func)
-	ZEND_NS_DEP_FALIAS("ZendTestNS2", namespaced_deprecated_func, ZendTestNS2_namespaced_deprecated_func, arginfo_ZendTestNS2_namespaced_deprecated_func)
-	ZEND_NS_FALIAS("ZendTestNS2", namespaced_aliased_func, zend_test_void_return, arginfo_ZendTestNS2_namespaced_aliased_func)
-	ZEND_NS_DEP_FALIAS("ZendTestNS2", namespaced_deprecated_aliased_func, zend_test_void_return, arginfo_ZendTestNS2_namespaced_deprecated_aliased_func)
-	ZEND_NS_FALIAS("ZendTestNS2\\ZendSubNS", namespaced_func, ZendTestNS2_ZendSubNS_namespaced_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_func)
-	ZEND_NS_DEP_FALIAS("ZendTestNS2\\ZendSubNS", namespaced_deprecated_func, ZendTestNS2_ZendSubNS_namespaced_deprecated_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_func)
-	ZEND_NS_FALIAS("ZendTestNS2\\ZendSubNS", namespaced_aliased_func, zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_aliased_func)
-	ZEND_NS_DEP_FALIAS("ZendTestNS2\\ZendSubNS", namespaced_deprecated_aliased_func, zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_aliased_func)
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_func"), zif_ZendTestNS2_namespaced_func, arginfo_ZendTestNS2_namespaced_func, 0, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_func"), zif_ZendTestNS2_namespaced_func, arginfo_ZendTestNS2_namespaced_func, 0)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_deprecated_func"), zif_ZendTestNS2_namespaced_deprecated_func, arginfo_ZendTestNS2_namespaced_deprecated_func, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_deprecated_func"), zif_ZendTestNS2_namespaced_deprecated_func, arginfo_ZendTestNS2_namespaced_deprecated_func, ZEND_ACC_DEPRECATED)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_namespaced_aliased_func, 0, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_namespaced_aliased_func, 0)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_deprecated_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_namespaced_deprecated_aliased_func, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2", "namespaced_deprecated_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_namespaced_deprecated_aliased_func, ZEND_ACC_DEPRECATED)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_func"), zif_ZendTestNS2_ZendSubNS_namespaced_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_func, 0, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_func"), zif_ZendTestNS2_ZendSubNS_namespaced_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_func, 0)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_deprecated_func"), zif_ZendTestNS2_ZendSubNS_namespaced_deprecated_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_func, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_deprecated_func"), zif_ZendTestNS2_ZendSubNS_namespaced_deprecated_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_func, ZEND_ACC_DEPRECATED)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_aliased_func, 0, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_aliased_func, 0)
+#endif
+#if (PHP_VERSION_ID >= 80400)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_deprecated_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_aliased_func, ZEND_ACC_DEPRECATED, NULL, NULL)
+#else
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("ZendTestNS2\\ZendSubNS", "namespaced_deprecated_aliased_func"), zif_zend_test_void_return, arginfo_ZendTestNS2_ZendSubNS_namespaced_deprecated_aliased_func, ZEND_ACC_DEPRECATED)
+#endif
 	ZEND_FE_END
 };
 
@@ -485,7 +537,8 @@ static zend_class_entry *register_class__ZendTestInterface(void)
 	zval const_DUMMY_value;
 	ZVAL_LONG(&const_DUMMY_value, 0);
 	zend_string *const_DUMMY_name = zend_string_init_interned("DUMMY", sizeof("DUMMY") - 1, 1);
-	zend_declare_class_constant_ex(class_entry, const_DUMMY_name, &const_DUMMY_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string *const_DUMMY_comment = zend_string_init_interned("/**\n         * \"Lorem ipsum\"\n         * @see https://www.php.net\n         * @since 8.2\n         */", 98, 1);
+	zend_declare_class_constant_ex(class_entry, const_DUMMY_name, &const_DUMMY_value, ZEND_ACC_PUBLIC, const_DUMMY_comment);
 	zend_string_release(const_DUMMY_name);
 
 	return class_entry;
@@ -760,11 +813,15 @@ static zend_class_entry *register_class_ZendTestPropertyAttribute(void)
 	INIT_CLASS_ENTRY(ce, "ZendTestPropertyAttribute", class_ZendTestPropertyAttribute_methods);
 	class_entry = zend_register_internal_class_ex(&ce, NULL);
 	class_entry->ce_flags |= ZEND_ACC_FINAL;
+#if (PHP_VERSION_ID >= 80400)
+	class_entry->doc_comment = zend_string_init_interned("/**\n     * \"Lorem ipsum\"\n     * @see https://www.php.net\n     * @since 8.1\n     */", 82, 1);
+#endif
 
 	zval property_parameter_default_value;
 	ZVAL_UNDEF(&property_parameter_default_value);
 	zend_string *property_parameter_name = zend_string_init("parameter", sizeof("parameter") - 1, 1);
-	zend_declare_typed_property(class_entry, property_parameter_name, &property_parameter_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
+	zend_string *property_parameter_comment = zend_string_init_interned("/**\n         * \"Lorem ipsum\"\n         * @see https://www.php.net\n         * @since 8.4\n         */", 98, 1);
+	zend_declare_typed_property(class_entry, property_parameter_name, &property_parameter_default_value, ZEND_ACC_PUBLIC, property_parameter_comment, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
 	zend_string_release(property_parameter_name);
 
 	zend_string *attribute_name_Attribute_class_ZendTestPropertyAttribute_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, 1);
diff --git a/ext/zend_test/tests/doc_comment_internal_symbols1.phpt b/ext/zend_test/tests/doc_comment_internal_symbols1.phpt
new file mode 100644
index 0000000000000..4d5b35170687f
--- /dev/null
+++ b/ext/zend_test/tests/doc_comment_internal_symbols1.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Test that exposing doc comments are supported by internal symbols
+--EXTENSIONS--
+zend_test
+reflection
+--FILE--
+<?php
+
+$rc = new ReflectionClass(ZendTestPropertyAttribute::class);
+var_dump($rc->getDocComment());
+
+$rc = new ReflectionClassConstant(_ZendTestInterface::class, "DUMMY");
+var_dump($rc->getDocComment());
+
+$rf = new ReflectionFunction("zend_test_nullable_array_return");
+var_dump($rf->getDocComment());
+
+$rp = new ReflectionProperty(new ZendTestPropertyAttribute(""), "parameter");
+var_dump($rp->getDocComment());
+
+?>
+--EXPECT--
+string(82) "/**
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.1
+     */"
+string(98) "/**
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.2
+         */"
+string(82) "/**
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.3
+     */"
+string(98) "/**
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.4
+         */"
diff --git a/ext/zend_test/tests/doc_comment_internal_symbols2.phpt b/ext/zend_test/tests/doc_comment_internal_symbols2.phpt
new file mode 100644
index 0000000000000..3816bc6da1a82
--- /dev/null
+++ b/ext/zend_test/tests/doc_comment_internal_symbols2.phpt
@@ -0,0 +1,82 @@
+--TEST--
+Test that displaying doc comments via reflection is supported by internal symbols
+--EXTENSIONS--
+zend_test
+reflection
+--FILE--
+<?php
+
+$rc = new ReflectionClass(ZendTestPropertyAttribute::class);
+echo $rc->__toString() . "\n";
+
+$rc = new ReflectionClassConstant(_ZendTestInterface::class, "DUMMY");
+echo $rc->__toString() . "\n";
+
+$rf = new ReflectionFunction("zend_test_nullable_array_return");
+echo $rf->__toString() . "\n";
+
+$rp = new ReflectionProperty(new ZendTestPropertyAttribute(""), "parameter");
+echo $rp->__toString() . "\n";
+
+?>
+--EXPECT--
+/**
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.1
+     */
+Class [ <internal:zend_test> final class ZendTestPropertyAttribute ] {
+
+  - Constants [0] {
+  }
+
+  - Static properties [0] {
+  }
+
+  - Static methods [0] {
+  }
+
+  - Properties [1] {
+    /**
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.4
+         */
+    Property [ public string $parameter ]
+  }
+
+  - Methods [1] {
+    Method [ <internal:zend_test, ctor> public method __construct ] {
+
+      - Parameters [1] {
+        Parameter #0 [ <required> string $parameter ]
+      }
+    }
+  }
+}
+
+/**
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.2
+         */
+Constant [ public int DUMMY ] { 0 }
+
+/**
+     * "Lorem ipsum"
+     * @see https://www.php.net
+     * @since 8.3
+     */
+Function [ <internal:zend_test> function zend_test_nullable_array_return ] {
+
+  - Parameters [0] {
+  }
+  - Return [ ?array ]
+}
+
+/**
+         * "Lorem ipsum"
+         * @see https://www.php.net
+         * @since 8.4
+         */
+Property [ public string $parameter ]
diff --git a/ext/zip/php_zip_arginfo.h b/ext/zip/php_zip_arginfo.h
index b3cc176d0105b..fc0621ea19b3c 100644
--- a/ext/zip/php_zip_arginfo.h
+++ b/ext/zip/php_zip_arginfo.h
@@ -404,16 +404,16 @@ ZEND_METHOD(ZipArchive, isEncryptionMethodSupported);
 #endif
 
 static const zend_function_entry ext_functions[] = {
-	ZEND_DEP_FE(zip_open, arginfo_zip_open)
-	ZEND_DEP_FE(zip_close, arginfo_zip_close)
-	ZEND_DEP_FE(zip_read, arginfo_zip_read)
-	ZEND_DEP_FE(zip_entry_open, arginfo_zip_entry_open)
-	ZEND_DEP_FE(zip_entry_close, arginfo_zip_entry_close)
-	ZEND_DEP_FE(zip_entry_read, arginfo_zip_entry_read)
-	ZEND_DEP_FE(zip_entry_name, arginfo_zip_entry_name)
-	ZEND_DEP_FE(zip_entry_compressedsize, arginfo_zip_entry_compressedsize)
-	ZEND_DEP_FE(zip_entry_filesize, arginfo_zip_entry_filesize)
-	ZEND_DEP_FE(zip_entry_compressionmethod, arginfo_zip_entry_compressionmethod)
+	ZEND_RAW_FENTRY("zip_open", zif_zip_open, arginfo_zip_open, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_close", zif_zip_close, arginfo_zip_close, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_read", zif_zip_read, arginfo_zip_read, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_open", zif_zip_entry_open, arginfo_zip_entry_open, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_close", zif_zip_entry_close, arginfo_zip_entry_close, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_read", zif_zip_entry_read, arginfo_zip_entry_read, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_name", zif_zip_entry_name, arginfo_zip_entry_name, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_compressedsize", zif_zip_entry_compressedsize, arginfo_zip_entry_compressedsize, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_filesize", zif_zip_entry_filesize, arginfo_zip_entry_filesize, ZEND_ACC_DEPRECATED, NULL, NULL)
+	ZEND_RAW_FENTRY("zip_entry_compressionmethod", zif_zip_entry_compressionmethod, arginfo_zip_entry_compressionmethod, ZEND_ACC_DEPRECATED, NULL, NULL)
 	ZEND_FE_END
 };
 
diff --git a/ext/zlib/zlib_arginfo.h b/ext/zlib/zlib_arginfo.h
index e2931be86ea80..1c0c9746d3d27 100644
--- a/ext/zlib/zlib_arginfo.h
+++ b/ext/zlib/zlib_arginfo.h
@@ -176,17 +176,17 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(gzinflate, arginfo_gzinflate)
 	ZEND_FE(gzdecode, arginfo_gzdecode)
 	ZEND_FE(gzuncompress, arginfo_gzuncompress)
-	ZEND_FALIAS(gzwrite, fwrite, arginfo_gzwrite)
-	ZEND_FALIAS(gzputs, fwrite, arginfo_gzputs)
-	ZEND_FALIAS(gzrewind, rewind, arginfo_gzrewind)
-	ZEND_FALIAS(gzclose, fclose, arginfo_gzclose)
-	ZEND_FALIAS(gzeof, feof, arginfo_gzeof)
-	ZEND_FALIAS(gzgetc, fgetc, arginfo_gzgetc)
-	ZEND_FALIAS(gzpassthru, fpassthru, arginfo_gzpassthru)
-	ZEND_FALIAS(gzseek, fseek, arginfo_gzseek)
-	ZEND_FALIAS(gztell, ftell, arginfo_gztell)
-	ZEND_FALIAS(gzread, fread, arginfo_gzread)
-	ZEND_FALIAS(gzgets, fgets, arginfo_gzgets)
+	ZEND_RAW_FENTRY("gzwrite", zif_fwrite, arginfo_gzwrite, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzputs", zif_fwrite, arginfo_gzputs, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzrewind", zif_rewind, arginfo_gzrewind, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzclose", zif_fclose, arginfo_gzclose, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzeof", zif_feof, arginfo_gzeof, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzgetc", zif_fgetc, arginfo_gzgetc, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzpassthru", zif_fpassthru, arginfo_gzpassthru, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzseek", zif_fseek, arginfo_gzseek, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gztell", zif_ftell, arginfo_gztell, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzread", zif_fread, arginfo_gzread, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("gzgets", zif_fgets, arginfo_gzgets, 0, NULL, NULL)
 	ZEND_FE(deflate_init, arginfo_deflate_init)
 	ZEND_FE(deflate_add, arginfo_deflate_add)
 	ZEND_FE(inflate_init, arginfo_inflate_init)
diff --git a/sapi/apache2handler/php_functions_arginfo.h b/sapi/apache2handler/php_functions_arginfo.h
index 92767dbae19ce..c5657e9429cab 100644
--- a/sapi/apache2handler/php_functions_arginfo.h
+++ b/sapi/apache2handler/php_functions_arginfo.h
@@ -51,7 +51,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(apache_lookup_uri, arginfo_apache_lookup_uri)
 	ZEND_FE(virtual, arginfo_virtual)
 	ZEND_FE(apache_request_headers, arginfo_apache_request_headers)
-	ZEND_FALIAS(getallheaders, apache_request_headers, arginfo_getallheaders)
+	ZEND_RAW_FENTRY("getallheaders", zif_apache_request_headers, arginfo_getallheaders, 0, NULL, NULL)
 	ZEND_FE(apache_response_headers, arginfo_apache_response_headers)
 	ZEND_FE(apache_note, arginfo_apache_note)
 	ZEND_FE(apache_setenv, arginfo_apache_setenv)
diff --git a/sapi/cgi/cgi_main_arginfo.h b/sapi/cgi/cgi_main_arginfo.h
index 0e1eeba21fe29..19ef6f01ad5ce 100644
--- a/sapi/cgi/cgi_main_arginfo.h
+++ b/sapi/cgi/cgi_main_arginfo.h
@@ -18,7 +18,7 @@ ZEND_FUNCTION(apache_response_headers);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(apache_child_terminate, arginfo_apache_child_terminate)
 	ZEND_FE(apache_request_headers, arginfo_apache_request_headers)
-	ZEND_FALIAS(getallheaders, apache_request_headers, arginfo_getallheaders)
+	ZEND_RAW_FENTRY("getallheaders", zif_apache_request_headers, arginfo_getallheaders, 0, NULL, NULL)
 	ZEND_FE(apache_response_headers, arginfo_apache_response_headers)
 	ZEND_FE_END
 };
diff --git a/sapi/fpm/fpm/fpm_main_arginfo.h b/sapi/fpm/fpm/fpm_main_arginfo.h
index 8c85a06168b42..2d6ae3cc79334 100644
--- a/sapi/fpm/fpm/fpm_main_arginfo.h
+++ b/sapi/fpm/fpm/fpm_main_arginfo.h
@@ -19,7 +19,7 @@ ZEND_FUNCTION(fpm_get_status);
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(fastcgi_finish_request, arginfo_fastcgi_finish_request)
 	ZEND_FE(apache_request_headers, arginfo_apache_request_headers)
-	ZEND_FALIAS(getallheaders, apache_request_headers, arginfo_getallheaders)
+	ZEND_RAW_FENTRY("getallheaders", zif_apache_request_headers, arginfo_getallheaders, 0, NULL, NULL)
 	ZEND_FE(fpm_get_status, arginfo_fpm_get_status)
 	ZEND_FE_END
 };
diff --git a/sapi/litespeed/lsapi_main_arginfo.h b/sapi/litespeed/lsapi_main_arginfo.h
index 849ba337066c0..4ba5419fe49a1 100644
--- a/sapi/litespeed/lsapi_main_arginfo.h
+++ b/sapi/litespeed/lsapi_main_arginfo.h
@@ -25,10 +25,10 @@ ZEND_FUNCTION(litespeed_finish_request);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(litespeed_request_headers, arginfo_litespeed_request_headers)
-	ZEND_FALIAS(getallheaders, litespeed_request_headers, arginfo_getallheaders)
-	ZEND_FALIAS(apache_request_headers, litespeed_request_headers, arginfo_apache_request_headers)
+	ZEND_RAW_FENTRY("getallheaders", zif_litespeed_request_headers, arginfo_getallheaders, 0, NULL, NULL)
+	ZEND_RAW_FENTRY("apache_request_headers", zif_litespeed_request_headers, arginfo_apache_request_headers, 0, NULL, NULL)
 	ZEND_FE(litespeed_response_headers, arginfo_litespeed_response_headers)
-	ZEND_FALIAS(apache_response_headers, litespeed_response_headers, arginfo_apache_response_headers)
+	ZEND_RAW_FENTRY("apache_response_headers", zif_litespeed_response_headers, arginfo_apache_response_headers, 0, NULL, NULL)
 	ZEND_FE(apache_get_modules, arginfo_apache_get_modules)
 	ZEND_FE(litespeed_finish_request, arginfo_litespeed_finish_request)
 	ZEND_FE_END