TAILCALL VM

Introduce the TAILCALL VM, a more efficient variant of the CALL VM:

 * Each opcode handler tailcalls the next opcode handler directly instead of
   returning to the interpreter loop. This eliminates call and interpreter loop
   overhead.
 * Opcode handlers use the preserve_none calling convention to eliminate
   register saving overhead.
 * preserve_none uses non-volatile registers for its first arguments, so
   execute_data and opline are usually kept in these registers and no code is
   required to forward them to the next handlers.

Generated machine code is similar to a direct-threaded VM with register pinning,
like the HYBRID VM.

JIT+TAILCALL VM also benefits from this compared to JIT+CALL VM:

 * JIT uses the registers of the execute_data and opline args as fixed regs,
   eliminating the need to move them in prologue.
 * Traces exit by tailcalling the next handler. No code is needed to forward
   execute_data and opline.
 * No register saving/restoring in epilogue/prologue.

The TAILCALL VM is used when the HYBRID VM is not supported, and the compiler
supports the musttail and preserve_none attributes: The HYBRID VM is used when
compiling with GCC, the TAILCALL VM when compiling with Clang>=19 on x86_64 or
aarch64, and the CALL VM otherwise.

This makes binaries built with Clang>=19 as fast as binaries built with GCC.
Before, these were considerably slower (by 2.8% to 44% depending on benchmark,
and by 5% to 77% before 76d7c61).

Closes GH-17849
Closes GH-18720

Author: arnaud-lb

NEWS

@@ -19,6 +19,8 @@ PHP                                                                        NEWS
     (alexandre-daubois)
   . Fixed bug GH-19544 (GC treats ZEND_WEAKREF_TAG_MAP references as WeakMap
     references). (Arnaud, timwolla)
+  . Introduced the TAILCALL VM, enabled by default when compiling with Clang>=19
+    on x86_64 or aarch64. (Arnaud)
 
 - Filter:
   . Added support for configuring the URI parser for FILTER_VALIDATE_URL

UPGRADING

@@ -883,6 +883,11 @@ PHP 8.5 UPGRADE NOTES
   . Creating exception objects is now much faster.
   . The parts of the code that used SSE2 have been adapted to use SIMD
     with ARM NEON as well.
+  . Introduced the TAILCALL VM, enabled by default when compiling with Clang>=19
+    on x86_64 or aarch64. The TAILCALL VM is as fast as the HYBRID VM used when
+    compiling with GCC. This makes PHP binaries built with Clang>=19 as fast as
+    binaries built with GCC. The performance of the CALL VM, used with other
+    compilers, has also improved considerably.
 
 - Intl:
   . Now avoids creating extra string copies when converting strings

Zend/Zend.m4

@@ -170,6 +170,7 @@ ZEND_CHECK_STACK_DIRECTION
 ZEND_CHECK_FLOAT_PRECISION
 ZEND_DLSYM_CHECK
 ZEND_CHECK_GLOBAL_REGISTER_VARIABLES
+ZEND_CHECK_PRESERVE_NONE
 ZEND_CHECK_CPUID_COUNT
 
 AC_MSG_CHECKING([whether to enable thread safety])
@@ -464,3 +465,103 @@ AS_VAR_IF([ZEND_MAX_EXECUTION_TIMERS], [yes],
 AC_MSG_CHECKING([whether to enable Zend max execution timers])
 AC_MSG_RESULT([$ZEND_MAX_EXECUTION_TIMERS])
 ])
+
+dnl
+dnl ZEND_CHECK_PRESERVE_NONE
+dnl
+dnl Check if the preserve_none calling convention is supported and matches our
+dnl expectations.
+dnl
+AC_DEFUN([ZEND_CHECK_PRESERVE_NONE], [dnl
+  AC_CACHE_CHECK([for preserve_none calling convention],
+   [php_cv_preverve_none],
+   [AC_RUN_IFELSE([AC_LANG_SOURCE([[
+#include <stdio.h>
+#include <stdint.h>
+
+const char * const1 = "str1";
+const char * const2 = "str2";
+const char * const3 = "str3";
+uint64_t key = UINT64_C(0x9d7f71d2bd296364);
+
+uintptr_t _a = 0;
+uintptr_t _b = 0;
+
+uintptr_t __attribute__((preserve_none)) fun(uintptr_t a, uintptr_t b) {
+	_a = a;
+	_b = b;
+	return (uintptr_t)const3;
+}
+
+uintptr_t __attribute__((preserve_none)) test(void) {
+	uintptr_t ret;
+
+#if defined(__x86_64__)
+	__asm__ __volatile__(
+		/* XORing to make it unlikely the value exists in any other register */
+		"movq %1, %%r12\n"
+		"xorq %3, %%r12\n"
+		"movq %2, %%r13\n"
+		"xorq %3, %%r13\n"
+		"xorq %%rax, %%rax\n"
+		"call fun\n"
+		: "=a" (ret)
+		: "r" (const1), "r" (const2), "r" (key)
+		: "r12", "r13"
+	);
+#elif defined(__aarch64__)
+	__asm__ __volatile__(
+		/* XORing to make it unlikely the value exists in any other register */
+		"eor    x20, %1, %3\n"
+		"eor    x21, %2, %3\n"
+		"eor    x0, x0, x0\n"
+		"bl     fun\n"
+		"mov    %0, x0\n"
+		: "=r" (ret)
+		: "r" (const1), "r" (const2), "r" (key)
+		: "x0", "x21", "x22", "x30"
+	);
+#else
+# error
+#endif
+
+	return ret;
+}
+
+int main(void) {
+
+	/* JIT is making the following expectations about preserve_none:
+	 * - The registers used for integer args 1 and 2
+	 * - The register used for a single integer return value
+	 *
+	 * We check these expectations here:
+	 */
+
+	uintptr_t ret = test();
+
+	if (_a != ((uintptr_t)const1 ^ key)) {
+		fprintf(stderr, "arg1 mismatch\n");
+		return 1;
+	}
+	if (_b != ((uintptr_t)const2 ^ key)) {
+		fprintf(stderr, "arg2 mismatch\n");
+		return 2;
+	}
+	if (ret != (uintptr_t)const3) {
+		fprintf(stderr, "ret mismatch\n");
+		return 3;
+	}
+
+	fprintf(stderr, "OK\n");
+
+	return 0;
+}]])],
+    [php_cv_preserve_none=yes],
+    [php_cv_preserve_none=no],
+    [php_cv_preserve_none=no])
+  ])
+  AS_VAR_IF([php_cv_preserve_none], [yes], [
+    AC_DEFINE([HAVE_PRESERVE_NONE], [1],
+      [Define to 1 if you have preserve_none support.])
+  ])
+])

Zend/zend_portability.h

@@ -321,6 +321,15 @@ char *alloca();
 # define ZEND_FASTCALL
 #endif
 
+#ifdef HAVE_PRESERVE_NONE
+# define ZEND_PRESERVE_NONE __attribute__((preserve_none))
+#endif
+
+#if __has_attribute(musttail)
+# define HAVE_MUSTTAIL
+# define ZEND_MUSTTAIL __attribute__((musttail))
+#endif
+
 #if (defined(__GNUC__) && __GNUC__ >= 3 && !defined(__INTEL_COMPILER) && !defined(__APPLE__) && !defined(__hpux) && !defined(_AIX) && !defined(__osf__)) || __has_attribute(noreturn)
 # define HAVE_NORETURN
 # define ZEND_NORETURN __attribute__((noreturn))

Zend/zend_vm_def.h

@@ -2962,7 +2962,10 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY)
 {
 	zend_execute_data *old_execute_data;
 	uint32_t call_info = EX_CALL_INFO();
+#if ZEND_VM_KIND != ZEND_VM_KIND_TAILCALL
+	/* zend_leave_helper may be called with opline=call_leave_op in TAILCALL VM */
 	SAVE_OPLINE();
+#endif
 
 	if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) {
 		EG(current_execute_data) = EX(prev_execute_data);
@@ -4917,7 +4920,7 @@ ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, CONST|UNUSED|NUM, SPE
 			ZEND_VM_C_GOTO(send_val_by_ref);
 		}
 	} else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
-ZEND_VM_C_LABEL(send_val_by_ref):
+ZEND_VM_C_LABEL(send_val_by_ref):;
 		ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper, _arg_num, arg_num, _arg, arg);
 	}
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
@@ -6162,7 +6165,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO
 			}
 
 			bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
-			if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {			
+			if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
 				if (c->ce->type == ZEND_USER_CLASS) {
 					/* Recursion protection only applied to user constants, GH-18463 */
 					CONST_PROTECT_RECURSION(c);