Optimize generic function param/return type checking performance

Eliminate per-parameter overhead for free generic functions by skipping
type checks at RECV time (no bound generic args to check against).
Return type enforcement via lazy inference handles correctness.

Key changes:
- Compiler sets RECV opline mask to MAY_BE_ANY for free function generic
  params, enabling RECV_NOTYPE fast path in both interpreter and JIT
- JIT skips arg type verification for free function generic params
- Pre-computed param_to_arg_map stored inline in generic_params_info for
  O(1) return type inference lookup (replaces O(N) arg_info scan)
- Fast path in zend_check_type() for generic param types in parameter
  position avoids non-inlined zend_check_type_slow() call
- Opcache persistence uses consistent ZEND_GENERIC_PARAMS_INFO_SIZE macro

Results: generic function overhead vs plain typed equivalent is now flat
at ~10-15% interpreter / ~1-8% JIT regardless of parameter count (was
scaling to -50% interp / -60% JIT for 8 params).

Co-Authored-By: Grok <noreply@x.ai>

Author: php-generics

Zend/zend_compile.c

@@ -8330,8 +8330,24 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32
 			| (is_promoted ? _ZEND_IS_PROMOTED_BIT : 0);
 		ZEND_TYPE_FULL_MASK(arg_info->type) |= arg_info_flags;
 		if (opcode == ZEND_RECV) {
-			opline->op2.num = type_ast ?
-				ZEND_TYPE_FULL_MASK(arg_info->type) : MAY_BE_ANY;
+			if (type_ast) {
+				uint32_t type_mask = ZEND_TYPE_FULL_MASK(arg_info->type);
+				/* For free function generic params (e.g., T $v), use MAY_BE_ANY
+				 * so the RECV handler's fast path always matches (or better,
+				 * the RECV_NOTYPE specialization is used). These params can't be
+				 * checked at receive time (no bound generic args for free
+				 * functions), and return type enforcement handles correctness.
+				 * Methods/constructors keep the original mask for proper checking. */
+				if ((type_mask & MAY_BE_GENERIC_PARAM)
+						&& !(type_mask & _ZEND_TYPE_MASK & ~MAY_BE_GENERIC_PARAM)
+						&& !CG(active_class_entry)) {
+					opline->op2.num = MAY_BE_ANY;
+				} else {
+					opline->op2.num = type_mask;
+				}
+			} else {
+				opline->op2.num = MAY_BE_ANY;
+			}
 		}
 
 		if (is_promoted) {
@@ -9086,6 +9102,34 @@ static zend_op_array *zend_compile_func_decl_ex(
 	/* Store function-level generic params on the op_array (class-level ones are on the CE) */
 	if (CG(active_generic_params) != saved_generic_params) {
 		op_array->generic_params_info = CG(active_generic_params);
+
+		/* Build param-to-arg map for O(1) return type inference.
+		 * Maps each generic param index to the function argument index where
+		 * it first appears, enabling direct lookup instead of linear scan. */
+		zend_generic_params_info *gpi = op_array->generic_params_info;
+		int16_t *map = ZEND_GENERIC_PARAMS_ARG_MAP(gpi);
+		/* Scan regular params */
+		for (uint32_t i = 0; i < op_array->num_args; i++) {
+			zend_arg_info *ai = &op_array->arg_info[i];
+			if (ZEND_TYPE_IS_GENERIC_PARAM(ai->type)) {
+				zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(ai->type);
+				if (ref->param_index < gpi->num_params
+						&& map[ref->param_index] == ZEND_GENERIC_ARG_UNMAPPED) {
+					map[ref->param_index] = (int16_t)i;
+				}
+			}
+		}
+		/* Scan variadic param */
+		if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
+			zend_arg_info *ai = &op_array->arg_info[op_array->num_args];
+			if (ZEND_TYPE_IS_GENERIC_PARAM(ai->type)) {
+				zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(ai->type);
+				if (ref->param_index < gpi->num_params
+						&& map[ref->param_index] == ZEND_GENERIC_ARG_UNMAPPED) {
+					map[ref->param_index] = ZEND_GENERIC_ARG_VARIADIC;
+				}
+			}
+		}
 	} else {
 		op_array->generic_params_info = NULL;
 	}

Zend/zend_execute.c

@@ -1299,40 +1299,24 @@ static inline bool zend_check_type_slow(
 			}
 		}
 		/* Lazy inference for generic functions (not just constructors).
-		 * Targeted: find the ONE argument that maps to gref->param_index,
-		 * infer its type, and check directly — zero allocation. */
+		 * Uses pre-computed param_to_arg_map for O(1) lookup instead of
+		 * scanning arg_info entries. */
 		if (!args && is_return_type) {
 			zend_execute_data *ex = EG(current_execute_data);
 			if (ex && ex->func && ex->func->type == ZEND_USER_FUNCTION
 					&& ex->func->op_array.generic_params_info) {
-				zend_function *func = ex->func;
+				zend_generic_params_info *gpi = ex->func->op_array.generic_params_info;
 				uint32_t target_idx = gref->param_index;
-				uint32_t num_func_args = func->common.num_args;
-				uint32_t num_call_args = ZEND_CALL_NUM_ARGS(ex);
 				zval *source_arg = NULL;
 
-				/* Scan regular params for the one matching target_idx */
-				for (uint32_t i = 0; i < num_func_args && i < num_call_args; i++) {
-					zend_arg_info *ai = &func->common.arg_info[i];
-					if (ZEND_TYPE_IS_GENERIC_PARAM(ai->type)) {
-						zend_generic_type_ref *r = ZEND_TYPE_GENERIC_PARAM_REF(ai->type);
-						if (r->param_index == target_idx) {
-							source_arg = ZEND_CALL_VAR_NUM(ex, i);
-							break;
-						}
-					}
-				}
-
-				/* Check variadic if not found */
-				if (!source_arg && (func->common.fn_flags & ZEND_ACC_VARIADIC)
-						&& num_call_args > num_func_args) {
-					zend_arg_info *ai = &func->common.arg_info[num_func_args];
-					if (ZEND_TYPE_IS_GENERIC_PARAM(ai->type)) {
-						zend_generic_type_ref *r = ZEND_TYPE_GENERIC_PARAM_REF(ai->type);
-						if (r->param_index == target_idx) {
-							source_arg = ZEND_CALL_VAR_NUM(ex,
-								func->op_array.last_var + func->op_array.T);
-						}
+				if (target_idx < gpi->num_params) {
+					int16_t arg_idx = ZEND_GENERIC_PARAMS_ARG_MAP(gpi)[target_idx];
+					if (arg_idx >= 0 && (uint32_t)arg_idx < ZEND_CALL_NUM_ARGS(ex)) {
+						source_arg = ZEND_CALL_VAR_NUM(ex, arg_idx);
+					} else if (arg_idx == ZEND_GENERIC_ARG_VARIADIC
+							&& ZEND_CALL_NUM_ARGS(ex) > ex->func->common.num_args) {
+						source_arg = ZEND_CALL_VAR_NUM(ex,
+							ex->func->op_array.last_var + ex->func->op_array.T);
 					}
 				}
 
@@ -1469,6 +1453,22 @@ static zend_always_inline bool zend_check_type(
 		return 1;
 	}
 
+	/* Fast path for generic param types in parameter position:
+	 * For free generic functions, param checks always pass (no args bound).
+	 * Skip the non-inlined zend_check_type_slow() call entirely.
+	 * Constructors of generic classes still need the slow path for inference. */
+	if (ZEND_TYPE_IS_GENERIC_PARAM(*type) && !is_return_type) {
+		zend_generic_args *gargs = i_zend_get_current_generic_args();
+		if (!gargs) {
+			zend_execute_data *ex = EG(current_execute_data);
+			if (!(ex && Z_TYPE(ex->This) == IS_OBJECT
+					&& Z_OBJ(ex->This)->ce->generic_params_info
+					&& (ex->func->common.fn_flags & ZEND_ACC_CTOR))) {
+				return 1;
+			}
+		}
+	}
+
 	return zend_check_type_slow(type, arg, ref, is_return_type, is_internal);
 }
 

Zend/zend_generics.c

@@ -23,16 +23,19 @@
 
 ZEND_API zend_generic_params_info *zend_alloc_generic_params_info(uint32_t num_params)
 {
-	zend_generic_params_info *info = safe_emalloc(
-		num_params - 1, sizeof(zend_generic_param),
-		sizeof(zend_generic_params_info));
+	zend_generic_params_info *info = emalloc(ZEND_GENERIC_PARAMS_INFO_SIZE(num_params));
 	info->num_params = num_params;
 	for (uint32_t i = 0; i < num_params; i++) {
 		info->params[i].name = NULL;
 		info->params[i].constraint = (zend_type) ZEND_TYPE_INIT_NONE(0);
 		info->params[i].default_type = (zend_type) ZEND_TYPE_INIT_NONE(0);
 		info->params[i].variance = ZEND_GENERIC_VARIANCE_INVARIANT;
 	}
+	/* Initialize param-to-arg map to unmapped */
+	int16_t *map = ZEND_GENERIC_PARAMS_ARG_MAP(info);
+	for (uint32_t i = 0; i < num_params; i++) {
+		map[i] = ZEND_GENERIC_ARG_UNMAPPED;
+	}
 	return info;
 }
 

Zend/zend_generics.h

@@ -79,6 +79,19 @@ typedef struct _zend_generic_class_ref {
 #define ZEND_GENERIC_ARGS_SIZE(n) \
 	(offsetof(zend_generic_args, args) + (n) * sizeof(zend_type) + (n) * sizeof(uint32_t))
 
+/* Allocation size for zend_generic_params_info with N params + N arg map entries */
+#define ZEND_GENERIC_PARAMS_INFO_SIZE(n) \
+	(offsetof(zend_generic_params_info, params) + (n) * sizeof(zend_generic_param) + (n) * sizeof(int16_t))
+
+/* Pre-computed mapping: param_to_arg_map[param_index] = function arg index.
+ * Stored inline after the params[] array. Only meaningful for function-level
+ * generic params. Eliminates O(N) arg_info scanning during return type checks. */
+#define ZEND_GENERIC_PARAMS_ARG_MAP(info) \
+	((int16_t*)(&(info)->params[(info)->num_params]))
+
+#define ZEND_GENERIC_ARG_UNMAPPED  ((int16_t)-1)  /* Param doesn't appear in any argument */
+#define ZEND_GENERIC_ARG_VARIADIC  ((int16_t)-2)  /* Param appears in the variadic argument */
+
 /* Allocation */
 ZEND_API zend_generic_params_info *zend_alloc_generic_params_info(uint32_t num_params);
 ZEND_API zend_generic_args *zend_alloc_generic_args(uint32_t num_args);

ext/opcache/jit/zend_jit_ir.c

@@ -10901,8 +10901,17 @@ static int zend_jit_recv(zend_jit_ctx *jit, const zend_op *opline, const zend_op
 		} else if (UNEXPECTED(op_array->fn_flags & ZEND_ACC_VARIADIC)) {
 			arg_info = &op_array->arg_info[op_array->num_args];
 		}
-		if (arg_info && !ZEND_TYPE_IS_SET(arg_info->type)) {
-			arg_info = NULL;
+		if (arg_info) {
+			if (!ZEND_TYPE_IS_SET(arg_info->type)) {
+				arg_info = NULL;
+			} else if (ZEND_TYPE_IS_GENERIC_PARAM(arg_info->type)
+					&& !(ZEND_TYPE_FULL_MASK(arg_info->type) & _ZEND_TYPE_MASK & ~MAY_BE_GENERIC_PARAM)
+					&& !op_array->scope) {
+				/* Free function generic param: skip JIT type check (matches
+				 * interpreter RECV_NOTYPE behavior). Return type enforcement
+				 * handles correctness via lazy inference. */
+				arg_info = NULL;
+			}
 		}
 	}
 

ext/opcache/zend_persist.c

@@ -433,7 +433,7 @@ static void zend_persist_generic_args(zend_generic_args **args_ptr)
 static void zend_persist_generic_params_info(zend_generic_params_info **info_ptr)
 {
 	zend_generic_params_info *info = *info_ptr;
-	size_t size = sizeof(zend_generic_params_info) + (info->num_params > 1 ? (info->num_params - 1) * sizeof(zend_generic_param) : 0);
+	size_t size = ZEND_GENERIC_PARAMS_INFO_SIZE(info->num_params);
 	info = zend_shared_memdup_put_free(info, size);
 	for (uint32_t i = 0; i < info->num_params; i++) {
 		zend_accel_store_interned_string(info->params[i].name);

ext/opcache/zend_persist_calc.c

@@ -250,7 +250,7 @@ static void zend_persist_generic_args_calc(zend_generic_args *args)
 
 static void zend_persist_generic_params_info_calc(zend_generic_params_info *info)
 {
-	ADD_SIZE(sizeof(zend_generic_params_info) + (info->num_params > 1 ? (info->num_params - 1) * sizeof(zend_generic_param) : 0));
+	ADD_SIZE(ZEND_GENERIC_PARAMS_INFO_SIZE(info->num_params));
 	for (uint32_t i = 0; i < info->num_params; i++) {
 		ADD_INTERNED_STRING(info->params[i].name);
 		zend_persist_type_calc(&info->params[i].constraint);