Also cache the computed stack size in INIT_FCALL_BY_NAME

The computed stack size only depends on the function definition fbc and the number
of opcodes in extended_value, and that doesn't change.

INIT_FCALL_BY_NAME is used when the function definition is not available when a
file is being compiled, commonly due to the function being declared in a
different file.
Precomputing the stack size is an optimization already done by INIT_FCALL
used when the function is known.

Replacing `hallo` in Zend/micro_bench.php with a require_once to load `hallo`
from a different file in a build with opcache enabled (but not the jit):

```
Before (best run) - total time and subtracting time needed for an empty loop
empty_loop         0.162
func_elsewhere()   0.615    0.475

After (best run):
empty_loop         0.159 (unaffected, just noise)
func_elsewhere()   0.579    0.420
```

Author: TysonAndre

Zend/Optimizer/compact_literals.c

@@ -634,7 +634,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 						opline->result.num = func_slot[opline->op2.constant];
 					} else {
 						opline->result.num = cache_size;
-						cache_size += sizeof(void *);
+						cache_size += opline->opcode == ZEND_INIT_FCALL_BY_NAME ? 2 * sizeof(void *) : sizeof(void *);
 						func_slot[opline->op2.constant] = opline->result.num;
 					}
 					break;

Zend/Optimizer/zend_optimizer.c

@@ -369,7 +369,7 @@ bool zend_optimizer_update_op2_const(zend_op_array *op_array,
 			drop_leading_backslash(val);
 			opline->op2.constant = zend_optimizer_add_literal(op_array, val);
 			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
-			opline->result.num = alloc_cache_slots(op_array, 1);
+			opline->result.num = alloc_cache_slots(op_array, 2);
 			break;
 		case ZEND_ASSIGN_STATIC_PROP:
 		case ZEND_ASSIGN_STATIC_PROP_REF:
@@ -422,7 +422,7 @@ bool zend_optimizer_update_op2_const(zend_op_array *op_array,
 				drop_leading_backslash(val);
 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
 				zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
-				opline->result.num = alloc_cache_slots(op_array, 1);
+				opline->result.num = alloc_cache_slots(op_array, 2);
 			} else {
 				opline->op2.constant = zend_optimizer_add_literal(op_array, val);
 			}

Zend/zend_compile.c

@@ -3706,7 +3706,7 @@ static void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast
 			opline->opcode = ZEND_INIT_FCALL_BY_NAME;
 			opline->op2_type = IS_CONST;
 			opline->op2.constant = zend_add_func_name_literal(str);
-			opline->result.num = zend_alloc_cache_slot();
+			opline->result.num = zend_alloc_cache_slots(2);
 		}
 	} else {
 		zend_emit_op(NULL, ZEND_INIT_DYNAMIC_CALL, NULL, name_node);

Zend/zend_vm_def.h

@@ -3749,7 +3749,8 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
 	zval *function_name, *func;
 	zend_execute_data *call;
 
-	fbc = CACHED_PTR(opline->result.num);
+	int num = opline->result.num;
+	fbc = CACHED_PTR(num);
 	if (UNEXPECTED(fbc == NULL)) {
 		function_name = (zval*)RT_CONSTANT(opline, opline->op2);
 		func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
@@ -3760,9 +3761,13 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
 			init_func_run_time_cache(&fbc->op_array);
 		}
-		CACHE_PTR(opline->result.num, fbc);
+		CACHE_PTR(num, fbc);
+		CACHE_PTR(num + sizeof(void*), (void*)(uintptr_t)zend_vm_calc_used_stack(opline->extended_value, fbc));
 	}
-	call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
+	/* Because zend_vm_calc_used_stack depends only on the number of arguments and the function definition fbc,
+	 * it can be cached in the run time cache. */
+	call = _zend_vm_stack_push_call_frame_ex(
+		(uint32_t)(uintptr_t)CACHED_PTR(num + sizeof(void*)), ZEND_CALL_NESTED_FUNCTION,
 		fbc, opline->extended_value, NULL);
 	call->prev_execute_data = EX(call);
 	EX(call) = call;

Zend/zend_vm_execute.h

@@ -3574,7 +3574,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME
 	zval *function_name, *func;
 	zend_execute_data *call;
 
-	fbc = CACHED_PTR(opline->result.num);
+	int num = opline->result.num;
+	fbc = CACHED_PTR(num);
 	if (UNEXPECTED(fbc == NULL)) {
 		function_name = (zval*)RT_CONSTANT(opline, opline->op2);
 		func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
@@ -3585,9 +3586,13 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME
 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
 			init_func_run_time_cache(&fbc->op_array);
 		}
-		CACHE_PTR(opline->result.num, fbc);
+		CACHE_PTR(num, fbc);
+		CACHE_PTR(num + sizeof(void*), (void*)(uintptr_t)zend_vm_calc_used_stack(opline->extended_value, fbc));
 	}
-	call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
+	/* Because zend_vm_calc_used_stack depends only on the number of arguments and the function definition fbc,
+	 * it can be cached in the run time cache. */
+	call = _zend_vm_stack_push_call_frame_ex(
+		(uint32_t)(uintptr_t)CACHED_PTR(num + sizeof(void*)), ZEND_CALL_NESTED_FUNCTION,
 		fbc, opline->extended_value, NULL);
 	call->prev_execute_data = EX(call);
 	EX(call) = call;