diff --git a/Zend/Optimizer/optimize_func_calls.c b/Zend/Optimizer/optimize_func_calls.c
index 819a33d93bb2e..e7af7211b0b85 100644
--- a/Zend/Optimizer/optimize_func_calls.c
+++ b/Zend/Optimizer/optimize_func_calls.c
@@ -78,7 +78,7 @@ static void zend_delete_call_instructions(zend_op_array *op_array, zend_op *opli
 
 static void zend_try_inline_call(zend_op_array *op_array, zend_op *fcall, zend_op *opline, zend_function *func)
 {
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (func->type == ZEND_USER_FUNCTION
 	 && !(func->op_array.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_HAS_TYPE_HINTS|ZEND_ACC_DEPRECATED|no_discard))
diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c
index 4e5ecca8a0f80..92c3d591b73b0 100644
--- a/Zend/Optimizer/zend_optimizer.c
+++ b/Zend/Optimizer/zend_optimizer.c
@@ -1726,7 +1726,7 @@ ZEND_API void zend_optimize_script(zend_script *script, zend_long optimization_l
 
 				ZEND_ASSERT(orig_op_array != NULL);
 				if (orig_op_array != op_array) {
-					uint32_t fn_flags = op_array->fn_flags;
+					zend_fn_flags fn_flags = op_array->fn_flags;
 					zend_function *prototype = op_array->prototype;
 					HashTable *ht = op_array->static_variables;
 
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index fa8b52c734c16..4fcf3a29a5896 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -37,7 +37,7 @@ typedef struct _zend_function_entry {
 	zif_handler handler;
 	const struct _zend_internal_arg_info *arg_info;
 	uint32_t num_args;
-	uint32_t flags;
+	zend_fn_flags flags;
 	const zend_frameless_function_info *frameless_function_infos;
 	const char *doc_comment;
 } zend_function_entry;
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index d0ce85dd3c6fb..119d9040b26d5 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -3916,7 +3916,7 @@ static uint32_t zend_compile_args(
 
 ZEND_API uint8_t zend_get_call_op(const zend_op *init_op, zend_function *fbc, bool result_used) /* {{{ */
 {
-	uint32_t no_discard = result_used ? 0 : ZEND_ACC_NODISCARD;
+	zend_fn_flags no_discard = result_used ? 0 : ZEND_ACC_NODISCARD;
 
 	if (fbc && init_op->opcode != ZEND_NEW) {
 		ZEND_ASSERT(!(fbc->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE));
@@ -7543,7 +7543,7 @@ static void zend_compile_attributes(
 				}
 			}
 
-			uint32_t flags = (CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES)
+			zend_fn_flags flags = (CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES)
 				? ZEND_ATTRIBUTE_STRICT_TYPES : 0;
 			attr = zend_add_attribute(
 				attributes, name, args ? args->children : 0, flags, offset, el->lineno);
@@ -8244,7 +8244,7 @@ static zend_string *zend_begin_method_decl(zend_op_array *op_array, zend_string
 {
 	zend_class_entry *ce = CG(active_class_entry);
 	bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0;
-	uint32_t fn_flags = op_array->fn_flags;
+	zend_fn_flags fn_flags = op_array->fn_flags;
 
 	zend_string *lcname;
 
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index c815248f78071..2848573513f13 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -341,7 +341,7 @@ typedef struct _zend_oparray_context {
 /* Class cannot be serialized or unserialized             |     |     |     */
 #define ZEND_ACC_NOT_SERIALIZABLE        (1 << 29) /*  X  |     |     |     */
 /*                                                        |     |     |     */
-/* Function Flags (unused: 30)                            |     |     |     */
+/* Function Flags (unused: 30,32-63)                      |     |     |     */
 /* ==============                                         |     |     |     */
 /*                                                        |     |     |     */
 /* Function returning by reference                        |     |     |     */
@@ -443,7 +443,7 @@ static zend_always_inline uint32_t zend_visibility_to_set_visibility(uint32_t vi
 // Must not clash with ZEND_SHORT_CIRCUITING_CHAIN_MASK
 #define ZEND_JMP_NULL_BP_VAR_IS 4
 
-const char *zend_visibility_string(uint32_t fn_flags);
+const char *zend_visibility_string(uint32_t flags);
 
 #define ZEND_PROPERTY_HOOK_COUNT 2
 #define ZEND_PROPERTY_HOOK_STRUCT_SIZE (sizeof(zend_function*) * ZEND_PROPERTY_HOOK_COUNT)
@@ -512,11 +512,13 @@ typedef struct _zend_internal_function_info {
 	const char *default_value;
 } zend_internal_function_info;
 
+typedef uint64_t zend_fn_flags;
+
 struct _zend_op_array {
 	/* Common elements */
 	uint8_t type;
 	uint8_t arg_flags[3]; /* bitset of arg_info.pass_by_reference */
-	uint32_t fn_flags;
+	zend_fn_flags fn_flags;
 	zend_string *function_name;
 	zend_class_entry *scope;
 	zend_function *prototype;
@@ -575,7 +577,7 @@ typedef struct _zend_internal_function {
 	/* Common elements */
 	uint8_t type;
 	uint8_t arg_flags[3]; /* bitset of arg_info.pass_by_reference */
-	uint32_t fn_flags;
+	zend_fn_flags fn_flags;
 	zend_string* function_name;
 	zend_class_entry *scope;
 	zend_function *prototype;
@@ -604,7 +606,7 @@ union _zend_function {
 	struct {
 		uint8_t type;  /* never used */
 		uint8_t arg_flags[3]; /* bitset of arg_info.pass_by_reference */
-		uint32_t fn_flags;
+		zend_fn_flags fn_flags;
 		zend_string *function_name;
 		zend_class_entry *scope;
 		zend_function *prototype;
diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c
index ae9e7b701213f..ec828f573f65a 100644
--- a/Zend/zend_enum.c
+++ b/Zend/zend_enum.c
@@ -439,7 +439,7 @@ static void zend_enum_register_func(zend_class_entry *ce, zend_known_string_id n
 
 void zend_enum_register_funcs(zend_class_entry *ce)
 {
-	const uint32_t fn_flags =
+	const zend_fn_flags fn_flags =
 		ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_ARENA_ALLOCATED;
 	zend_internal_function *cases_function = zend_arena_calloc(&CG(arena), sizeof(zend_internal_function), 1);
 	cases_function->handler = zend_enum_cases_func;
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 48b978b535014..5d3f837de90b6 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -118,7 +118,7 @@ struct _zend_compiler_globals {
 	                              /* and don't use them as lead/trail units     */
 
 	zend_string *doc_comment;
-	uint32_t extra_fn_flags;
+	zend_fn_flags extra_fn_flags;
 
 	uint32_t compiler_options; /* set of ZEND_COMPILE_* constants */
 
diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c
index a2da64b62c0d5..345d6138fdabb 100644
--- a/Zend/zend_inheritance.c
+++ b/Zend/zend_inheritance.c
@@ -200,27 +200,27 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
 }
 /* }}} */
 
-const char *zend_visibility_string(uint32_t fn_flags) /* {{{ */
+const char *zend_visibility_string(uint32_t flags) /* {{{ */
 {
-	if (fn_flags & ZEND_ACC_PUBLIC) {
+	if (flags & ZEND_ACC_PUBLIC) {
 		return "public";
-	} else if (fn_flags & ZEND_ACC_PRIVATE) {
+	} else if (flags & ZEND_ACC_PRIVATE) {
 		return "private";
 	} else {
-		ZEND_ASSERT(fn_flags & ZEND_ACC_PROTECTED);
+		ZEND_ASSERT(flags & ZEND_ACC_PROTECTED);
 		return "protected";
 	}
 }
 /* }}} */
 
-static const char *zend_asymmetric_visibility_string(uint32_t fn_flags) /* {{{ */
+static const char *zend_asymmetric_visibility_string(uint32_t flags) /* {{{ */
 {
-	if (fn_flags & ZEND_ACC_PRIVATE_SET) {
+	if (flags & ZEND_ACC_PRIVATE_SET) {
 		return "private(set)";
-	} else if (fn_flags & ZEND_ACC_PROTECTED_SET) {
+	} else if (flags & ZEND_ACC_PROTECTED_SET) {
 		return "protected(set)";
 	} else {
-		ZEND_ASSERT(!(fn_flags & ZEND_ACC_PUBLIC_SET));
+		ZEND_ASSERT(!(flags & ZEND_ACC_PUBLIC_SET));
 		return "omitted";
 	}
 }
@@ -1126,8 +1126,8 @@ static inheritance_status do_inheritance_check_on_method(
 		zend_function *parent, zend_class_entry *parent_scope,
 		zend_class_entry *ce, zval *child_zv, uint32_t flags) /* {{{ */
 {
-	uint32_t child_flags;
-	uint32_t parent_flags = parent->common.fn_flags;
+	zend_fn_flags child_flags;
+	zend_fn_flags parent_flags = parent->common.fn_flags;
 	zend_function *proto;
 
 #define SEPARATE_METHOD() do { \
@@ -1408,7 +1408,7 @@ static void inherit_property_hook(
 
 	child->common.prototype = parent->common.prototype ? parent->common.prototype : parent;
 
-	uint32_t parent_flags = parent->common.fn_flags;
+	zend_fn_flags parent_flags = parent->common.fn_flags;
 	if (parent_flags & ZEND_ACC_PRIVATE) {
 		child->common.fn_flags |= ZEND_ACC_CHANGED;
 		return;
@@ -2440,7 +2440,7 @@ static void zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce) /*
 }
 /* }}} */
 
-static void zend_traits_check_private_final_inheritance(uint32_t original_fn_flags, const zend_function *fn_copy, const zend_string *name)
+static void zend_traits_check_private_final_inheritance(zend_fn_flags original_fn_flags, const zend_function *fn_copy, const zend_string *name)
 {
 	/* If the function was originally already private+final, then it will have
 	 * already been warned about. Only emit this error when the used trait method
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 3ebf816cf3817..ae17e38ebda02 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4200,7 +4200,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER))
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -4311,7 +4311,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index b0d6f2bc33d96..b2a21d83c6351 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1615,7 +1615,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -1728,7 +1728,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -1841,7 +1841,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -1952,7 +1952,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -2082,7 +2082,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -2212,7 +2212,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57154,7 +57154,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57267,7 +57267,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57380,7 +57380,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FC
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57491,7 +57491,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57621,7 +57621,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
@@ -57751,7 +57751,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FC
 	SAVE_OPLINE();
 	EX(call) = call->prev_execute_data;
 
-	const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
+	const zend_fn_flags no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 	if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
 		if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index f0d3379534591..286ca93914386 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -4359,7 +4359,7 @@ static void preload_fix_trait_op_array(zend_op_array *op_array)
 
 	zend_string *function_name = op_array->function_name;
 	zend_class_entry *scope = op_array->scope;
-	uint32_t fn_flags = op_array->fn_flags;
+	zend_fn_flags fn_flags = op_array->fn_flags;
 	zend_function *prototype = op_array->prototype;
 	HashTable *ht = op_array->static_variables;
 	*op_array = *orig_op_array;
diff --git a/ext/opcache/jit/zend_jit_ir.c b/ext/opcache/jit/zend_jit_ir.c
index 1c5cab899e783..b0bf1d2088a06 100644
--- a/ext/opcache/jit/zend_jit_ir.c
+++ b/ext/opcache/jit/zend_jit_ir.c
@@ -4629,7 +4629,7 @@ static struct jit_observer_fcall_is_unobserved_data jit_observer_fcall_is_unobse
 		// JIT: if (function->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_GENERATOR)) {
 		ZEND_ASSERT(rx != IR_UNUSED);
 		ir_ref if_trampoline_or_generator = ir_IF(ir_AND_U32(
-			ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags))),
+			ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags)))),
 			ir_CONST_U32(ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_GENERATOR)));
 		ir_IF_TRUE(if_trampoline_or_generator);
 		ir_END_list(data.ir_end_inputs);
@@ -8440,7 +8440,7 @@ static int zend_jit_free_trampoline(zend_jit_ctx *jit, ir_ref func)
 {
 	// JIT: if (UNEXPECTED(func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
 	ir_ref if_trampoline = ir_IF(ir_AND_U32(
-		ir_LOAD_U32(ir_ADD_OFFSET(func, offsetof(zend_function, common.fn_flags))),
+		ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func, offsetof(zend_function, common.fn_flags)))),
 		ir_CONST_U32(ZEND_ACC_CALL_VIA_TRAMPOLINE)));
 
 	ir_IF_TRUE(if_trampoline);
@@ -8665,7 +8665,7 @@ static int zend_jit_push_call_frame(zend_jit_ctx *jit, const zend_op *opline, co
 		//      (closure->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE);
 		call_info = ir_OR_U32(
 			ir_AND_U32(
-				ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_closure, func.common.fn_flags))),
+				ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_closure, func.common.fn_flags)))),
 				ir_CONST_U32(ZEND_ACC_FAKE_CLOSURE)),
 			ir_CONST_U32(ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC | ZEND_CALL_CLOSURE));
 		// JIT: if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
@@ -9117,7 +9117,7 @@ static int zend_jit_init_method_call(zend_jit_ctx         *jit,
 	if (!func) {
 		// JIT: if (fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		if_static = ir_IF(ir_AND_U32(
-			ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags))),
+			ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags)))),
 			ir_CONST_U32(ZEND_ACC_STATIC)));
 		ir_IF_TRUE_cold(if_static);
 	}
@@ -9288,7 +9288,7 @@ static int zend_jit_init_static_method_call(zend_jit_ctx         *jit,
 		if (!func) {
 			// JIT: if (fbc->common.fn_flags & ZEND_ACC_STATIC) {
 			if_static = ir_IF(ir_AND_U32(
-				ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags))),
+				ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_function, common.fn_flags)))),
 				ir_CONST_U32(ZEND_ACC_STATIC)));
 			ir_IF_FALSE_cold(if_static);
 		}
@@ -10104,7 +10104,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 				func_ref = ir_LOAD_A(jit_CALL(rx, func));
 				ir_GUARD_NOT(
 					ir_AND_U32(
-						ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags))),
+						ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags)))),
 						ir_CONST_U32(ZEND_ACC_DEPRECATED|ZEND_ACC_NODISCARD)),
 					ir_CONST_ADDR(exit_addr));
 			}
@@ -10136,7 +10136,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 				uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
 
 				if_deprecated_nodiscard = ir_IF(ir_AND_U32(
-						ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags))),
+						ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags)))),
 						ir_CONST_U32(ZEND_ACC_DEPRECATED|no_discard)));
 				ir_IF_TRUE_cold(if_deprecated_nodiscard);
 
@@ -10349,7 +10349,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 				if (!func) {
 					// JIT: if (EXPECTED((op_array->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) == 0))
 					ir_ref if_has_type_hints = ir_IF(ir_AND_U32(
-						ir_LOAD_U32(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags))),
+						ir_TRUNC_U32(ir_LOAD_U64(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, fn_flags)))),
 						ir_CONST_U32(ZEND_ACC_HAS_TYPE_HINTS)));
 					ir_IF_TRUE(if_has_type_hints);
 					ir_END_list(merge_inputs);
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index a0c1b9f812430..ab150af914b76 100644
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -3748,7 +3748,9 @@ ZEND_METHOD(ReflectionMethod, getModifiers)
 {
 	reflection_object *intern;
 	zend_function *mptr;
-	uint32_t keep_flags = ZEND_ACC_PPP_MASK
+	/* Keep in mind that all userland-exposed flags should fit in the low 32-bits
+	 * for 32-bit architectures. Shuffle ZEND_ACC_* flags around accordingly. */
+	zend_fn_flags keep_flags = ZEND_ACC_PPP_MASK
 		| ZEND_ACC_STATIC | ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL;
 
 	ZEND_PARSE_PARAMETERS_NONE();
diff --git a/main/debug_gdb_scripts.c b/main/debug_gdb_scripts.c
index e3c522bc04843..9090f2a9f51cf 100644
--- a/main/debug_gdb_scripts.c
+++ b/main/debug_gdb_scripts.c
@@ -1222,7 +1222,7 @@ asm(
     ".ascii \"\\n\"\n"
     ".ascii \"    def invoke (self, arg, from_tty):\\n\"\n"
     ".ascii \"        arg = int(gdb.parse_and_eval(arg))\\n\"\n"
-    ".ascii \"        print(ZendAccFlags.format_flags(arg, self.type))\\n\"\n"
+    ".ascii \"        print(ZendAccFlags.format_flags(arg, self.type, size=32))\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"PrintAccFlagsCommand('fn')\\n\"\n"
     ".ascii \"PrintAccFlagsCommand('ce')\\n\"\n"
@@ -1380,10 +1380,10 @@ asm(
     ".ascii \"        return self._flags[name]\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
-    ".ascii \"    def format_flags(self, flags, type):\\n\"\n"
+    ".ascii \"    def format_flags(self, flags, type, size):\\n\"\n"
     ".ascii \"        flags = int(flags)\\n\"\n"
     ".ascii \"        names = []\\n\"\n"
-    ".ascii \"        for i in range(0, 31):\\n\"\n"
+    ".ascii \"        for i in range(0, size - 1):\\n\"\n"
     ".ascii \"            if (flags & (1 << i)) != 0:\\n\"\n"
     ".ascii \"                name = self.flag_name(i, type)\\n\"\n"
     ".ascii \"                if name == None:\\n\"\n"
@@ -1394,19 +1394,19 @@ asm(
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
     ".ascii \"    def format_fn_flags(self, flags):\\n\"\n"
-    ".ascii \"        return self.format_flags(flags, 'fn')\\n\"\n"
+    ".ascii \"        return self.format_flags(flags, 'fn', 64)\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
     ".ascii \"    def format_ce_flags(self, flags):\\n\"\n"
-    ".ascii \"        return self.format_flags(flags, 'ce')\\n\"\n"
+    ".ascii \"        return self.format_flags(flags, 'ce', 32)\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
     ".ascii \"    def format_prop_flags(self, flags):\\n\"\n"
-    ".ascii \"        return self.format_flags(flags, 'prop')\\n\"\n"
+    ".ascii \"        return self.format_flags(flags, 'prop', 32)\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
     ".ascii \"    def format_const_flags(self, flags):\\n\"\n"
-    ".ascii \"        return self.format_flags(flags, 'const')\\n\"\n"
+    ".ascii \"        return self.format_flags(flags, 'const', 32)\\n\"\n"
     ".ascii \"\\n\"\n"
     ".ascii \"    @classmethod\\n\"\n"
     ".ascii \"    def _load(self):\\n\"\n"
@@ -1421,7 +1421,7 @@ asm(
     ".ascii \"        with open(filename, 'r') as file:\\n\"\n"
     ".ascii \"            content = file.read()\\n\"\n"
     ".ascii \"\\n\"\n"
-    ".ascii \"            pattern = re.compile(r'#define (ZEND_ACC_[^\\\\s]+)\\\\s+\\\\(1U\?\\\\s+<<\\\\s+(\\\\d+)\\\\)\\\\s+/\\\\*\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\*/')\\n\"\n"
+    ".ascii \"            pattern = re.compile(r'#define (ZEND_ACC_[^\\\\s]+)\\\\s+\\\\(1[uU]\?[lL]\?[lL]\?\\\\s+<<\\\\s+(\\\\d+)\\\\)\\\\s+/\\\\*\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\|\\\\s+(X\?)\\\\s+\\\\*/')\\n\"\n"
     ".ascii \"            matches = pattern.findall(content)\\n\"\n"
     ".ascii \"            for name, bit, cls, func, prop, const in matches:\\n\"\n"
     ".ascii \"                flags[name] = ZendAccFlag(cls == 'X', func == 'X', prop == 'X', const == 'X', int(bit))\\n\"\n"
diff --git a/scripts/gdb/php_gdb.py b/scripts/gdb/php_gdb.py
index 1c5da0154aecd..6d2745889eb67 100644
--- a/scripts/gdb/php_gdb.py
+++ b/scripts/gdb/php_gdb.py
@@ -552,7 +552,7 @@ def __init__ (self, type):
 
     def invoke (self, arg, from_tty):
         arg = int(gdb.parse_and_eval(arg))
-        print(ZendAccFlags.format_flags(arg, self.type))
+        print(ZendAccFlags.format_flags(arg, self.type, size=32))
 
 PrintAccFlagsCommand('fn')
 PrintAccFlagsCommand('ce')
@@ -710,10 +710,10 @@ def flag_bit(self, name):
         return self._flags[name]
 
     @classmethod
-    def format_flags(self, flags, type):
+    def format_flags(self, flags, type, size):
         flags = int(flags)
         names = []
-        for i in range(0, 31):
+        for i in range(0, size - 1):
             if (flags & (1 << i)) != 0:
                 name = self.flag_name(i, type)
                 if name == None:
@@ -724,19 +724,19 @@ def format_flags(self, flags, type):
 
     @classmethod
     def format_fn_flags(self, flags):
-        return self.format_flags(flags, 'fn')
+        return self.format_flags(flags, 'fn', 64)
 
     @classmethod
     def format_ce_flags(self, flags):
-        return self.format_flags(flags, 'ce')
+        return self.format_flags(flags, 'ce', 32)
 
     @classmethod
     def format_prop_flags(self, flags):
-        return self.format_flags(flags, 'prop')
+        return self.format_flags(flags, 'prop', 32)
 
     @classmethod
     def format_const_flags(self, flags):
-        return self.format_flags(flags, 'const')
+        return self.format_flags(flags, 'const', 32)
 
     @classmethod
     def _load(self):
@@ -751,7 +751,7 @@ def _load(self):
         with open(filename, 'r') as file:
             content = file.read()
 
-            pattern = re.compile(r'#define (ZEND_ACC_[^\s]+)\s+\(1U?\s+<<\s+(\d+)\)\s+/\*\s+(X?)\s+\|\s+(X?)\s+\|\s+(X?)\s+\|\s+(X?)\s+\*/')
+            pattern = re.compile(r'#define (ZEND_ACC_[^\s]+)\s+\(1[uU]?[lL]?[lL]?\s+<<\s+(\d+)\)\s+/\*\s+(X?)\s+\|\s+(X?)\s+\|\s+(X?)\s+\|\s+(X?)\s+\*/')
             matches = pattern.findall(content)
             for name, bit, cls, func, prop, const in matches:
                 flags[name] = ZendAccFlag(cls == 'X', func == 'X', prop == 'X', const == 'X', int(bit))