A new PHP JIT implementation based on IR JIT framework

Zend/zend_vm_execute.skl

@@ -13,6 +13,16 @@ ZEND_API void {%EXECUTOR_NAME%}_ex(zend_execute_data *ex)
 
 	{%INTERNAL_LABELS%}
 
+#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
+	/* Force C compiler to store preserved registers to allow JIT using them */
+# if defined(__GNUC__) && defined(__i386__)
+	__asm__ __volatile__ (""::: "ebx");
+# elif defined(__GNUC__) && defined(__x86_64__)
+	__asm__ __volatile__ (""::: "rbx","r12","r13");
+# elif defined(__GNUC__) && defined(__aarch64__)
+	__asm__ __volatile__ (""::: "x19","x20","x21","x22","x23","x24","x25","x26");
+# endif
+#endif
 	LOAD_OPLINE();
 	ZEND_VM_LOOP_INTERRUPT_CHECK();
 

Zend/zend_vm_gen.php

@@ -2046,14 +2046,14 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name)
                     } else {
                         out($f,"#if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)\n");
                         out($f,$m[1]."struct {\n");
+                        out($f,"#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE\n");
+                        out($f,$m[1]."\tchar hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];\n");
+                        out($f,"#endif\n");
                         out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n");
                         out($f,$m[1]."\tconst zend_op *orig_opline;\n");
                         out($f,"#endif\n");
                         out($f,"#ifdef ZEND_VM_FP_GLOBAL_REG\n");
                         out($f,$m[1]."\tzend_execute_data *orig_execute_data;\n");
-                        out($f,"#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE\n");
-                        out($f,$m[1]."\tchar hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];\n");
-                        out($f,"#endif\n");
                         out($f,"#endif\n");
                         out($f,$m[1]."} vm_stack_data;\n");
                         out($f,"#endif\n");
@@ -2339,7 +2339,7 @@ function gen_vm_opcodes_header(
     $str .= "\n";
     $str .= "#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) && !defined(__SANITIZE_ADDRESS__)\n";
     $str .= "# if ((defined(i386) && !defined(__PIC__)) || defined(__x86_64__) || defined(_M_X64))\n";
-    $str .= "#  define ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE 16\n";
+    $str .= "#  define ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE 48\n";
     $str .= "# endif\n";
     $str .= "#endif\n";
     $str .= "\n";

build/Makefile.global

@@ -122,6 +122,11 @@ clean:
 	rm -f ext/opcache/jit/zend_jit_x86.c
 	rm -f ext/opcache/jit/zend_jit_arm64.c
 	rm -f ext/opcache/minilua
+	rm -f ext/opcache/jit/ir/gen_ir_fold_hash
+	rm -f ext/opcache/jit/ir/minilua
+	rm -f ext/opcache/jit/ir/ir_fold_hash.h
+	rm -f ext/opcache/jit/ir/ir_emit_x86.h
+	rm -f ext/opcache/jit/ir/ir_emit_aarch64.h
 
 distclean: clean
 	rm -f Makefile config.cache config.log config.status Makefile.objects Makefile.fragments libtool main/php_config.h main/internal_functions_cli.c main/internal_functions.c Zend/zend_dtrace_gen.h Zend/zend_dtrace_gen.h.bak Zend/zend_config.h

ext/opcache/config.m4

@@ -24,6 +24,13 @@ PHP_ARG_WITH([capstone],,
   [no],
   [no])
 
+PHP_ARG_ENABLE([opcache-jit-ir],
+  [whether to enable JIT based on IR framework],
+  [AS_HELP_STRING([--disable-opcache-jit-ir],
+    [Disable JIT based on IR framework (use old JIT)])],
+  [yes],
+  [no])
+
 if test "$PHP_OPCACHE" != "no"; then
 
   dnl Always build as shared extension
@@ -44,7 +51,7 @@ if test "$PHP_OPCACHE" != "no"; then
     esac
   fi
 
-  if test "$PHP_OPCACHE_JIT" = "yes"; then
+  if test "$PHP_OPCACHE_JIT" = "yes" -a "$PHP_OPCACHE_JIT_IR" = "no" ; then
     AC_DEFINE(HAVE_JIT, 1, [Define to enable JIT])
     ZEND_JIT_SRC="jit/zend_jit.c jit/zend_jit_gdb.c jit/zend_jit_vm_helpers.c"
 
@@ -86,6 +93,62 @@ if test "$PHP_OPCACHE" != "no"; then
 
     PHP_SUBST(DASM_FLAGS)
     PHP_SUBST(DASM_ARCH)
+
+    JIT_CFLAGS=
+
+  elif test "$PHP_OPCACHE_JIT" = "yes" -a "$PHP_OPCACHE_JIT_IR" = "yes"; then
+    AC_DEFINE(HAVE_JIT, 1, [Define to enable JIT])
+    AC_DEFINE(ZEND_JIT_IR, 1, [Use JIT IR framework])
+    ZEND_JIT_SRC="jit/zend_jit.c jit/zend_jit_vm_helpers.c jit/ir/ir.c jit/ir/ir_strtab.c \
+		jit/ir/ir_cfg.c	jit/ir/ir_sccp.c jit/ir/ir_gcm.c jit/ir/ir_ra.c jit/ir/ir_save.c \
+		jit/ir/ir_dump.c jit/ir/ir_gdb.c jit/ir/ir_perf.c jit/ir/ir_check.c \
+		jit/ir/ir_patch.c jit/ir/ir_emit.c"
+
+    dnl Find out which ABI we are using.
+    case $host_alias in
+      x86_64-*-darwin*)
+        IR_TARGET=IR_TARGET_X64
+        DASM_FLAGS="-D X64APPLE=1 -D X64=1"
+        DASM_ARCH="x86"
+        ;;
+      x86_64*)
+        IR_TARGET=IR_TARGET_X64
+        DASM_FLAGS="-D X64=1"
+        DASM_ARCH="x86"
+        ;;
+      i[[34567]]86*)
+        IR_TARGET=IR_TARGET_X86
+        DASM_ARCH="x86"
+        ;;
+      x86*)
+        IR_TARGET=IR_TARGET_X86
+        DASM_ARCH="x86"
+        ;;
+      aarch64*)
+        IR_TARGET=IR_TARGET_AARCH64
+        DASM_ARCH="aarch64"
+        ;;
+     esac
+
+    AS_IF([test x"$with_capstone" = "xyes"],[
+      PKG_CHECK_MODULES([CAPSTONE],[capstone >= 3.0.0],[
+        AC_DEFINE([HAVE_CAPSTONE], [1], [Capstone is available])
+        PHP_EVAL_LIBLINE($CAPSTONE_LIBS, OPCACHE_SHARED_LIBADD)
+        PHP_EVAL_INCLINE($CAPSTONE_CFLAGS)
+        ZEND_JIT_SRC+=" jit/ir/ir_disasm.c"
+      ],[
+        AC_MSG_ERROR([capstone >= 3.0 required but not found])
+      ])
+    ])
+
+    PHP_SUBST(IR_TARGET)
+    PHP_SUBST(DASM_FLAGS)
+    PHP_SUBST(DASM_ARCH)
+
+    JIT_CFLAGS="-I@ext_builddir@/jit/ir -D${IR_TARGET} -DIR_PHP"
+    if test "$ZEND_DEBUG" = "yes"; then
+      JIT_CFLAGS="${JIT_CFLAGS} -DIR_DEBUG"
+    fi
   fi
 
   AC_CHECK_FUNCS([mprotect memfd_create shm_create_largepage])
@@ -310,7 +373,7 @@ int main(void) {
 	shared_alloc_mmap.c \
 	shared_alloc_posix.c \
 	$ZEND_JIT_SRC,
-	shared,,"-Wno-implicit-fallthrough -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1",,yes)
+	shared,,"-Wno-implicit-fallthrough -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1 ${JIT_CFLAGS}",,yes)
 
   PHP_ADD_EXTENSION_DEP(opcache, pcre)
 
@@ -320,6 +383,9 @@ int main(void) {
 
   if test "$PHP_OPCACHE_JIT" = "yes"; then
     PHP_ADD_BUILD_DIR([$ext_builddir/jit], 1)
+    if test "$PHP_OPCACHE_JIT_IR" = "yes"; then
+      PHP_ADD_BUILD_DIR([$ext_builddir/jit/ir], 1)
+    fi
     PHP_ADD_MAKEFILE_FRAGMENT($ext_srcdir/jit/Makefile.frag)
   fi
   PHP_SUBST(OPCACHE_SHARED_LIBADD)

ext/opcache/config.w32

@@ -5,6 +5,8 @@ if (PHP_OPCACHE != "no") {
 
 	ARG_ENABLE("opcache-jit", "whether to enable JIT", "yes");
 
+	ARG_ENABLE("opcache-jit-ir", "whether to enable JIT based on IR framework", "yes");
+
 	ZEND_EXTENSION('opcache', "\
 		ZendAccelerator.c \
 		zend_accelerator_blacklist.c \
@@ -18,7 +20,7 @@ if (PHP_OPCACHE != "no") {
 		zend_shared_alloc.c \
 		shared_alloc_win32.c", true, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
 
-	if (PHP_OPCACHE_JIT == "yes") {
+	if (PHP_OPCACHE_JIT == "yes" && PHP_OPCACHE_JIT_IR == "no") {
 		if (CHECK_HEADER_ADD_INCLUDE("dynasm/dasm_x86.h", "CFLAGS_OPCACHE", PHP_OPCACHE + ";ext\\opcache\\jit")) {
 			var dasm_flags = (X64 ? "-D X64=1" : "") + (X64 ? " -D X64WIN=1" : "") + " -D WIN=1";
 			if (PHP_ZTS == "yes") {
@@ -37,6 +39,45 @@ if (PHP_OPCACHE != "no") {
 		} else {
 			WARNING("JIT not enabled, headers not found");
 		}
+	} else if (PHP_OPCACHE_JIT == "yes" && PHP_OPCACHE_JIT_IR == "yes") {
+		if (CHECK_HEADER_ADD_INCLUDE("ir/ir.h", "CFLAGS_OPCACHE", PHP_OPCACHE + ";ext\\opcache\\jit")) {
+			var dasm_flags = (X64 ? "-D X64=1" : "") + (X64 ? " -D X64WIN=1" : "") + " -D WIN=1";
+			var ir_target = (X64 ? "IR_TARGET_X64" : "IR_TARGET_X86");
+			var ir_src = "ir_strtab.c ir_cfg.c ir_sccp.c ir_gcm.c ir_ra.c ir_save.c \
+				 ir_dump.c ir_check.c ir_patch.c";
+
+			DEFINE("IR_TARGET", ir_target);
+			DEFINE("DASM_FLAGS", dasm_flags);
+			DEFINE("DASM_ARCH", "x86");
+
+			AC_DEFINE('HAVE_JIT', 1, 'Define to enable JIT');
+			AC_DEFINE('ZEND_JIT_IR', 1, 'Use JIT IR framework');
+
+			ADD_FLAG("CFLAGS_OPCACHE", "/I \"ext\\opcache\\jit\\ir\" /D "+ir_target+" /D IR_PHP");
+			if (PHP_DEBUG == "yes") {
+				ADD_FLAG("CFLAGS_OPCACHE", "/D IR_DEBUG");
+			}
+
+			if (CHECK_HEADER_ADD_INCLUDE("capstone\\capstone.h", "CFLAGS_OPCACHE", PHP_OPCACHE+ ";" + PHP_PHP_BUILD + "\\include") &&
+				CHECK_LIB("capstone.lib", "opcache", PHP_OPCACHE)) {
+				AC_DEFINE('HAVE_CAPSTONE', 1, 'capstone support enabled');
+				ir_src += " ir_disasm.c";
+			}
+
+			ADD_MAKEFILE_FRAGMENT(configure_module_dirname + "\\jit\\Makefile.frag.w32");
+
+			ADD_SOURCES(configure_module_dirname + "\\jit",
+				"zend_jit.c zend_jit_vm_helpers.c",
+				"opcache", "ext\\opcache\\jit");
+			ADD_SOURCES(configure_module_dirname + "\\jit\\ir",
+				"ir.c", "opcache", "ext\\opcache\\jit\\ir");
+			ADD_SOURCES(configure_module_dirname + "\\jit\\ir",
+				"ir_emit.c", "opcache", "ext\\opcache\\jit\\ir");
+			ADD_SOURCES(configure_module_dirname + "\\jit\\ir",
+				ir_src, "opcache", "ext\\opcache\\jit\\ir");
+		} else {
+			WARNING("JIT not enabled, headers not found");
+		}
 	}
 
 	ADD_FLAG('CFLAGS_OPCACHE', "/I " + configure_module_dirname);

ext/opcache/jit/Makefile.frag

@@ -1,4 +1,29 @@
+ifdef IR_TARGET
+# New IR based JIT
+$(builddir)/jit/ir/minilua: $(srcdir)/jit/ir/dynasm/minilua.c
+	$(BUILD_CC) $(srcdir)/jit/ir/dynasm/minilua.c -lm -o $@
 
+$(builddir)/jit/ir/ir_emit_$(DASM_ARCH).h: $(srcdir)/jit/ir/ir_$(DASM_ARCH).dasc $(srcdir)/jit/ir/dynasm/*.lua $(builddir)/jit/ir/minilua
+	$(builddir)/jit/ir/minilua $(srcdir)/jit/ir/dynasm/dynasm.lua  $(DASM_FLAGS) -o $@ $(srcdir)/jit/ir/ir_$(DASM_ARCH).dasc
+
+$(builddir)/jit/ir/ir_emit.lo: \
+	$(srcdir)/jit/ir/ir_emit.c $(builddir)/jit/ir/ir_emit_$(DASM_ARCH).h
+
+$(builddir)/jit/ir/gen_ir_fold_hash: $(srcdir)/jit/ir/gen_ir_fold_hash.c $(srcdir)/jit/ir/ir_strtab.c
+	$(BUILD_CC) -D${IR_TARGET} -DIR_PHP -DIR_PHP_MM=0 -o $@ $<
+
+$(builddir)/jit/ir/ir_fold_hash.h: $(builddir)/jit/ir/gen_ir_fold_hash $(srcdir)/jit/ir/ir_fold.h $(srcdir)/jit/ir/ir.h
+	$(builddir)/jit/ir/gen_ir_fold_hash < $(srcdir)/jit/ir/ir_fold.h > $(builddir)/jit/ir/ir_fold_hash.h
+
+$(builddir)/jit/ir/ir.lo: \
+	$(builddir)/jit/ir/ir_fold_hash.h
+
+$(builddir)/jit/zend_jit.lo: \
+	$(srcdir)/jit/zend_jit_helpers.c \
+	$(srcdir)/jit/zend_jit_ir.c
+
+else
+# Old DynAsm based JIT
 $(builddir)/minilua: $(srcdir)/jit/dynasm/minilua.c
 	$(BUILD_CC) $(srcdir)/jit/dynasm/minilua.c -lm -o $@
 
@@ -15,6 +40,8 @@ $(builddir)/jit/zend_jit.lo: \
 	$(srcdir)/jit/zend_jit_trace.c \
 	$(srcdir)/jit/zend_elf.c
 
+endif
+
 # For non-GNU make, jit/zend_jit.lo and ./jit/zend_jit.lo are considered distinct targets.
 # Use this workaround to allow building from inside ext/opcache.
 jit/zend_jit.lo: $(builddir)/jit/zend_jit.lo

ext/opcache/jit/Makefile.frag.w32

@@ -1,3 +1,48 @@
+!if "$(IR_TARGET)" != ""
+# New IR based JIT
+
+$(BUILD_DIR)\\minilua.exe: ext\opcache\jit\ir\dynasm\minilua.c
+	@if exist $(BUILD_DIR)\\minilua.exe del $(BUILD_DIR)\\minilua.exe
+	$(PHP_CL) /Fo$(BUILD_DIR)\ /Fd$(BUILD_DIR)\ /Fp$(BUILD_DIR)\ /FR$(BUILD_DIR) /Fe$(BUILD_DIR)\minilua.exe ext\opcache\jit\ir\dynasm\minilua.c
+
+ext\opcache\jit\ir\ir_emit_x86.h: ext\opcache\jit\ir\ir_x86.dasc $(BUILD_DIR)\\minilua.exe
+	@if exist ext\opcache\jit\ir\ir_emit_x86.h del ext\opcache\jit\ir\ir_emit_x86.h
+	$(BUILD_DIR)\\minilua.exe ext/opcache/jit/ir/dynasm/dynasm.lua $(DASM_FLAGS) -o $@ ext/opcache/jit/ir/ir_x86.dasc
+
+$(BUILD_DIR)\\gen_ir_fold_hash.exe: ext\opcache\jit\ir\gen_ir_fold_hash.c ext\opcache\jit\ir\ir_strtab.c
+	@if exist $(BUILD_DIR)\\gen_ir_fold_hash.exe del $(BUILD_DIR)\\gen_ir_fold_hash.exe
+	$(PHP_CL) /D $(IR_TARGET) /Fo$(BUILD_DIR)\ /Fd$(BUILD_DIR)\ /Fp$(BUILD_DIR)\ /Fe$(BUILD_DIR)\\gen_ir_fold_hash.exe ext\opcache\jit\ir\gen_ir_fold_hash.c
+
+ext\opcache\jit\ir\ir_fold_hash.h: $(BUILD_DIR)\\gen_ir_fold_hash.exe ext\opcache\jit\ir\ir_fold.h ext\opcache\jit\ir\ir.h
+	@if exist ext\opcache\jit\ir\ir_fold_hash.h del ext\opcache\jit\ir\ir_fold_hash.h
+	$(BUILD_DIR)\\gen_ir_fold_hash.exe < ext\opcache\jit\ir\ir_fold.h > ext\opcache\jit\ir\ir_fold_hash.h
+
+$(BUILD_DIR)\ext\opcache\jit\ir\ir_ra.obj: \
+	ext\opcache\jit\ir\ir.h \
+	ext\opcache\jit\ir\ir_private.h \
+	ext\opcache\jit\ir\ir_x86.h
+
+$(BUILD_DIR)\ext\opcache\jit\ir\ir_emit.obj: \
+	ext\opcache\jit\ir\ir.h \
+	ext\opcache\jit\ir\ir_private.h \
+	ext\opcache\jit\ir\ir_x86.h \
+	ext\opcache\jit\ir\ir_emit_x86.h
+
+$(BUILD_DIR)\ext\opcache\jit\ir\ir.obj: \
+	ext\opcache\jit\ir\ir.h \
+	ext\opcache\jit\ir\ir_private.h \
+	ext\opcache\jit\ir\ir_fold.h \
+	ext\opcache\jit\ir\ir_fold_hash.h
+
+$(BUILD_DIR)\ext\opcache\jit\zend_jit.obj: \
+	ext\opcache\jit\zend_jit_ir.c \
+	ext\opcache\jit\zend_jit_helpers.c \
+	ext\opcache\jit\ir\ir.h \
+	ext\opcache\jit\ir\ir_builder.h
+
+!else
+# Old DynAsm based JIT
+
 $(BUILD_DIR)\\minilua.exe: ext\opcache\jit\dynasm\minilua.c
 	@if exist $(BUILD_DIR)\\minilua.exe del $(BUILD_DIR)\\minilua.exe
 	$(PHP_CL) /Fo$(BUILD_DIR)\ /Fd$(BUILD_DIR)\ /Fp$(BUILD_DIR)\ /FR$(BUILD_DIR) /Fe$(BUILD_DIR)\minilua.exe ext\opcache\jit\dynasm\minilua.c
@@ -14,3 +59,4 @@ $(BUILD_DIR)\ext\opcache\jit\zend_jit.obj: \
 	ext/opcache/jit/zend_jit_perf_dump.c \
 	ext/opcache/jit/zend_jit_trace.c \
 	ext/opcache/jit/zend_jit_vtune.c
+!endif

ext/opcache/jit/README-IR.md

@@ -0,0 +1,32 @@
+New JIT implementation
+======================
+
+This branch provides a new JIT implementation based on [IR - Lightweight
+JIT Compilation Framework](https://github.com/dstogov/ir).
+
+As opposed to the PHP 8.* JIT approach that generates native code directly from
+PHP byte-code, this implementation generates intermediate representation (IR)
+and delegates all lower-level tasks to the IR Framework. IR for JIT is like an
+AST for compiler.
+
+Key benefits of the new JIT implementation:
+- Usage of IR opens possibilities for better optimization and register
+  allocation (the resulting native code is more efficient)
+- PHP doesn't have to care about most low-level details (different CPUs,
+  calling conventions, TLS details, etc)
+- it's much easier to implement support for new targets (e.g. RISCV)
+- IR framework is going to be developed separately from PHP and may accept
+  contributions from other projects (new optimizations, improvements, bug fixes)
+
+Disadvantages:
+- JIT compilation becomes slower (this is almost invisible for tracing
+  JIT, but function JIT compilation of Wordpress becomes 4 times slower)
+
+The necessary part of the IR Framework is embedded into php-src. So, the PR
+doesn't introduce new dependencies.
+
+The new JIT implementation successfully passes all CI workflows, but it's still
+not mature and may cause failures. To reduce risks, this patch doesn't remove
+the old JIT implementation (that is the same as PHP-8.3 JIT). It's possible
+to build PHP with the old JIT by configuring with **--disable-opcache-jit-ir**.
+In the future the old implementation should be removed.