[jit] Move out-of-process JIT cells from clang-20 to clang-22 (#924)

[ci] Move out-of-process JIT cells to llvm22.

The OOP-JIT cells were pinned to clang-20 by
patches/llvm/clang20-1-out-of-process.patch, which carried the
clang::Interpreter::JITConfig surface CppInterOp depended on.
Upstream release/22.x carries the equivalent surface as
clang::IncrementalExecutorBuilder, so port
lib/CppInterOp/Compatibility.h to it and bump both OOP cells
(ubu24-x86 + osx26-arm) to clang-22 / python-3.14. The 966-line
patch goes away; the cells line up with the rest of the matrix.

Wire UpdateOrcRuntimePathCB into IncrementalCompilerBuilder so the
orc_rt archive path is discovered from the driver's toolchain during
CreateCpp() rather than hard-coded for x86_64 Linux; this also
unblocks aarch64 Linux, so relax the CMakeLists OOP-JIT guard.

Drop the public C-API pid_t GetExecutorPID() and its internal
helper: upstream has no executor-PID accessor, the entry has no
in-tree callers, and stubbing it to 0 would silently regress callers
expecting a real PID.

The upstream FDSimpleRemoteEPCTransport::sendMessage write(buf)
uninit-bytes report persists in 22.x; replace
etc/clang20-valgrind.supp with etc/clang22-valgrind.supp that
anchors on the offending function and uses a "..." tail (the old
supp pinned a libstdc++ .so version that no longer matches noble).

Separately, clang-22 introduces an x86_64-only regression in many
AST/Sema readers (clean on aarch64). Filed upstream as
llvm/llvm-project#194147 with a one-line reproducer. The
suppression file carries entries for the affected families:
InitListExpr accessors, Sema::CheckForIntOverflow,
SequenceChecker, Stmt::children, AnalyzeImplicitConversions,
CFGBuilder::Visit, RecordExprEvaluator and AggExprEmitter
init-list visits, InitListChecker::FillInEmpty*. Drop those
entries when the upstream issue is resolved.

On aarch64 / Ubuntu 24.04 against release/22.x: 349 tests
(in-process + OOP-JIT variants), 320 PASSED, 29 SKIPPED. The
OOP-JIT-vg cell on x86_64 reports 273 suppressions across 50
contexts and exits 0.

Author: vgvassilev

.github/actions/Build_LLVM/action.yml

@@ -39,10 +39,6 @@ runs:
           ninja LLVMOrcDebugging -j ${{ env.ncpus }}
           ninja clingInterpreter -j ${{ env.ncpus }}
         else
-          if [[ "${{ matrix.oop-jit }}" == "On" ]]; then
-            git apply -v ../patches/llvm/clang20-1-out-of-process.patch
-            echo "Apply clang20-1-out-of-process.patch:"
-          fi
           cd build
           cmake -DLLVM_ENABLE_PROJECTS="${{ matrix.llvm_enable_projects || 'clang' }}" \
                 -DLLVM_TARGETS_TO_BUILD="${{ matrix.llvm_targets_to_build || 'host;NVPTX' }}"  \

.github/workflows/main.yml

@@ -77,8 +77,6 @@ jobs:
         #   llvm_enable_projects: "clang"
         #   llvm_targets_to_build: "host;NVPTX"
         #   python-version:       '3.14'
-        # oop-jit stays on clang-20: patches/llvm/clang20-1-out-of-process.patch
-        # only targets release/20.x; bump when a matching patch lands.
         include:
           # Ubuntu Arm
           - { name: ubu24-arm-gcc12-llvm22-vg, os: ubuntu-24.04-arm, compiler: gcc-12, clang-runtime: '22', Valgrind: On }
@@ -93,26 +91,24 @@ jobs:
             compiler: gcc-12
             clang-runtime: '22'
             coverage: true
-          - name: ubu24-x86-gcc12-llvm20-oop-vg
+          - name: ubu24-x86-gcc12-llvm22-oop-vg
             os: ubuntu-24.04
             compiler: gcc-12
-            clang-runtime: '20'
+            clang-runtime: '22'
             llvm_enable_projects: "clang;compiler-rt"
             oop-jit: On
             Valgrind: On
-            python-version: '3.13'
           # MacOS Arm
           - { name: osx26-arm-clang-llvm22, os: macos-26, compiler: clang, clang-runtime: '22', llvm_targets_to_build: host }
           - { name: osx26-arm-clang-llvm21-cppyy, os: macos-26, compiler: clang, clang-runtime: '21', cppyy: On, llvm_targets_to_build: host }
           - { name: osx26-arm-clang-cling-llvm20-cppyy, os: macos-26, compiler: clang, clang-runtime: '20', cling: On, cppyy: On, root-llvm-tag: *root_llvm_tag }
-          - name: osx26-arm-clang-llvm20-oop
+          - name: osx26-arm-clang-llvm22-oop
             os: macos-26
             compiler: clang
-            clang-runtime: '20'
+            clang-runtime: '22'
             llvm_enable_projects: "clang;compiler-rt"
             llvm_targets_to_build: host
             oop-jit: On
-            python-version: '3.13'
           # MacOS X86
           - { name: osx26-x86-clang-llvm21-cppyy, os: macos-26-intel, compiler: clang, clang-runtime: '21', cppyy: On, llvm_targets_to_build: host }
           - { name: osx26-x86-clang-cling-llvm20-cppyy, os: macos-26-intel, compiler: clang, clang-runtime: '20', cling: On, cppyy: On, root-llvm-tag: *root_llvm_tag }

CMakeLists.txt

@@ -344,10 +344,10 @@ add_definitions(-DLLVM_BINARY_LIB_DIR="${LLVM_BINARY_LIB_DIR}")
 
 if(LLVM_BUILT_WITH_OOP_JIT)
   if((CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64") OR
-     (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64"))
+     (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|aarch64|arm64"))
     add_definitions(-DLLVM_BUILT_WITH_OOP_JIT)
   else()
-    message(FATAL_ERROR "LLVM_BUILT_WITH_OOP_JIT is only supported on MacOS arm64 or Linux x86_64. Build aborted.")
+    message(FATAL_ERROR "LLVM_BUILT_WITH_OOP_JIT is only supported on MacOS arm64 or Linux (x86_64/aarch64). Build aborted.")
   endif()
 endif()
 

etc/clang20-valgrind.supp

@@ -0,0 +1,125 @@
+# Upstream LLVM write(buf) uninit-bytes via the EPC transport, still
+# present in release/22.x. No llvm/llvm-project issue filed yet; if you
+# touch this file, please file one and add a reference here.
+{
+   Clang 22 Out of Process: uninitialised bytes in FDSimpleRemoteEPCTransport::sendMessage
+   Memcheck:Param
+   write(buf)
+   fun:__libc_write
+   fun:write
+   fun:_ZN4llvm3orc26FDSimpleRemoteEPCTransport11sendMessageENS0_21SimpleRemoteEPCOpcodeEmNS0_12ExecutorAddrENS_8ArrayRefIcEE
+   ...
+}
+
+# llvm/llvm-project#194147: clang-22 on x86_64 reads uninitialised bytes
+# in many AST/Sema paths (regression vs clang-20). Architecture-dependent
+# (clean on aarch64). Drop this whole block once the upstream issue lands.
+
+{
+   llvm/llvm-project#194147: InitListExpr::isTransparent
+   Memcheck:Cond
+   fun:_ZNK5clang12InitListExpr13isTransparentEv
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListExpr::getInit
+   Memcheck:Cond
+   fun:_ZN5clang12InitListExpr7getInitEj
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListExpr::getInit const
+   Memcheck:Cond
+   fun:_ZNK5clang12InitListExpr7getInitEj
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListExpr::setInit
+   Memcheck:Cond
+   fun:_ZN5clang12InitListExpr7setInitEjPNS_4ExprE
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListExpr::resizeInits
+   Memcheck:Cond
+   fun:_ZN5clang12InitListExpr11resizeInitsERKNS_10ASTContextEj
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListExpr::resizeInits via memset
+   Memcheck:Cond
+   fun:memset
+   fun:_ZN5clang12InitListExpr11resizeInitsERKNS_10ASTContextEj
+   ...
+}
+
+{
+   llvm/llvm-project#194147: Sema::CheckForIntOverflow Cond
+   Memcheck:Cond
+   fun:_ZN5clang4Sema19CheckForIntOverflowEPKNS_4ExprE
+   ...
+}
+{
+   llvm/llvm-project#194147: Sema::CheckForIntOverflow Value8
+   Memcheck:Value8
+   fun:_ZN5clang4Sema19CheckForIntOverflowEPKNS_4ExprE
+   ...
+}
+{
+   llvm/llvm-project#194147: SequenceChecker::SequenceExpressionsInOrder
+   Memcheck:Cond
+   fun:*SequenceChecker*SequenceExpressionsInOrder*
+   ...
+}
+
+{
+   llvm/llvm-project#194147: Stmt::children via AnalyzeImplicitConversions
+   Memcheck:Cond
+   fun:_ZN5clang4Stmt8childrenEv
+   fun:*AnalyzeImplicitConversions*
+   ...
+}
+{
+   llvm/llvm-project#194147: AnalyzeImplicitConversions leaf
+   Memcheck:Cond
+   fun:*AnalyzeImplicitConversions*
+   ...
+}
+{
+   llvm/llvm-project#194147: CFGBuilder::Visit Cond
+   Memcheck:Cond
+   fun:*CFGBuilder*Visit*
+   ...
+}
+{
+   llvm/llvm-project#194147: CFGBuilder::Visit Value8
+   Memcheck:Value8
+   fun:*CFGBuilder*Visit*
+   ...
+}
+
+{
+   llvm/llvm-project#194147: RecordExprEvaluator::VisitCXXParenListOrInitListExpr
+   Memcheck:Cond
+   fun:*RecordExprEvaluator*VisitCXXParenListOrInitListExpr*
+   ...
+}
+{
+   llvm/llvm-project#194147: AggExprEmitter init-list visits
+   Memcheck:Cond
+   fun:*AggExprEmitter*Visit*InitListExpr*
+   ...
+}
+
+{
+   llvm/llvm-project#194147: InitListChecker::FillInEmptyInitForField
+   Memcheck:Cond
+   fun:*InitListChecker*FillInEmptyInitForField*
+   ...
+}
+{
+   llvm/llvm-project#194147: InitListChecker::FillInEmptyInitializations
+   Memcheck:Cond
+   fun:*InitListChecker*FillInEmptyInitializations*
+   ...
+}

etc/clang22-valgrind.supp

@@ -20,20 +20,12 @@
 
 #include "CppInterOp/CppInterOpTypes.h"
 
-#include <sys/types.h>
-
 namespace CppImpl {
 
 // Public API function declarations. Generated by cppinterop-tblgen
 // from CppInterOp.td. Do not edit this section by hand.
 #include "CppInterOp/CppInterOpDecl.inc"
 
-#ifndef _WIN32
-/// Returns the process ID of the executor process.
-/// \returns the PID of the executor process.
-CPPINTEROP_API pid_t GetExecutorPID();
-#endif
-
 } // namespace CppImpl
 
 // NOLINTNEXTLINE(misc-unused-alias-decls)

include/CppInterOp/CppInterOp.h

@@ -237,6 +237,7 @@ inline void codeComplete(std::vector<std::string>& Results,
 
 #ifdef LLVM_BUILT_WITH_OOP_JIT
 #include "clang/Basic/Version.h"
+#include "clang/Interpreter/IncrementalExecutor.h"
 
 #include "llvm/ExecutionEngine/Orc/Debugging/DebuggerSupport.h"
 
@@ -392,6 +393,29 @@ createClangInterpreter(std::vector<const char*>& args, int stdin_fd = -1,
   clang::IncrementalCompilerBuilder CB;
   CB.SetCompilerArgs(CompilerArgs);
 
+  bool outOfProcess;
+#if defined(_WIN32) || !defined(LLVM_BUILT_WITH_OOP_JIT)
+  outOfProcess = false;
+#else
+  outOfProcess = std::any_of(args.begin(), args.end(), [](const char* arg) {
+    return llvm::StringRef(arg).trim() == "--use-oop-jit";
+  });
+#endif
+
+#ifdef LLVM_BUILT_WITH_OOP_JIT
+  // Why: UpdateOrcRuntimePathCB is the upstream hook that discovers the
+  // orc_rt location from the driver's toolchain during CreateCpp() /
+  // CreateCudaHost(); it only fires when IsOutOfProcess is already true,
+  // so the flag and the callback must be set before the CompilerInstance
+  // is built.
+  auto OutOfProcessConfig =
+      std::make_unique<clang::IncrementalExecutorBuilder>();
+  if (outOfProcess) {
+    OutOfProcessConfig->IsOutOfProcess = true;
+    CB.SetDriverCompilationCallback(OutOfProcessConfig->UpdateOrcRuntimePathCB);
+  }
+#endif
+
   std::unique_ptr<clang::CompilerInstance> DeviceCI;
   if (CudaEnabled) {
     if (OffloadArch.empty())
@@ -421,48 +445,29 @@ createClangInterpreter(std::vector<const char*>& args, int stdin_fd = -1,
   if (CudaEnabled)
     DeviceCI->LoadRequestedPlugins();
 
-  bool outOfProcess;
-#if defined(_WIN32) || !defined(LLVM_BUILT_WITH_OOP_JIT)
-  outOfProcess = false;
-#else
-  outOfProcess = std::any_of(args.begin(), args.end(), [](const char* arg) {
-    return llvm::StringRef(arg).trim() == "--use-oop-jit";
-  });
-#endif
-
 #ifdef LLVM_BUILT_WITH_OOP_JIT
-
-  clang::Interpreter::JITConfig OutOfProcessConfig;
   if (outOfProcess) {
-    OutOfProcessConfig.IsOutOfProcess = true;
-    OutOfProcessConfig.OOPExecutor =
+    OutOfProcessConfig->OOPExecutor =
         LLVM_BINARY_LIB_DIR "/bin/llvm-jitlink-executor";
-    OutOfProcessConfig.UseSharedMemory = false;
-    OutOfProcessConfig.SlabAllocateSize = 0;
-    OutOfProcessConfig.CustomizeFork = [stdin_fd, stdout_fd,
-                                        stderr_fd]() { // Lambda defined inline
+    OutOfProcessConfig->UseSharedMemory = false;
+    OutOfProcessConfig->SlabAllocateSize = 0;
+    OutOfProcessConfig->CustomizeFork = [stdin_fd, stdout_fd,
+                                         stderr_fd]() { // Lambda defined inline
       dup2(stdin_fd, STDIN_FILENO);
       dup2(stdout_fd, STDOUT_FILENO);
       dup2(stderr_fd, STDERR_FILENO);
 
       setvbuf(fdopen(stdout_fd, "w+"), nullptr, _IONBF, 0);
       setvbuf(fdopen(stderr_fd, "w+"), nullptr, _IONBF, 0);
     };
-
-#ifdef __APPLE__
-    std::string OrcRuntimePath = LLVM_BINARY_LIB_DIR "/lib/clang/" STRINGIFY(
-        LLVM_VERSION_MAJOR) "/lib/darwin/liborc_rt_osx.a";
-#else
-    std::string OrcRuntimePath = LLVM_BINARY_LIB_DIR "/lib/clang/" STRINGIFY(
-        LLVM_VERSION_MAJOR) "/lib/x86_64-unknown-linux-gnu/liborc_rt.a";
-#endif
-    OutOfProcessConfig.OrcRuntimePath = OrcRuntimePath;
+    // OrcRuntimePath was populated by UpdateOrcRuntimePathCB above.
   }
   auto innerOrErr =
-      CudaEnabled
-          ? clang::Interpreter::createWithCUDA(std::move(*ciOrErr),
-                                               std::move(DeviceCI))
-          : clang::Interpreter::create(std::move(*ciOrErr), OutOfProcessConfig);
+      CudaEnabled ? clang::Interpreter::createWithCUDA(std::move(*ciOrErr),
+                                                       std::move(DeviceCI))
+                  : clang::Interpreter::create(
+                        std::move(*ciOrErr),
+                        outOfProcess ? std::move(OutOfProcessConfig) : nullptr);
 #else
   if (outOfProcess) {
     llvm::errs()

lib/CppInterOp/Compatibility.h

@@ -4833,16 +4833,4 @@ int Undo(unsigned N) {
 #endif
 }
 
-#ifndef _WIN32
-pid_t GetExecutorPID() {
-  INTEROP_TRACE();
-#ifdef LLVM_BUILT_WITH_OOP_JIT
-  auto& I = getInterp();
-  return INTEROP_RETURN(I.getOutOfProcessExecutorPID());
-#endif
-  return INTEROP_RETURN(getpid());
-}
-
-#endif
-
 } // namespace CppImpl

lib/CppInterOp/CppInterOp.cpp

@@ -335,15 +335,6 @@ class Interpreter {
     return llvm::orc::ExecutorAddr(*AddrOrErr);
   }
 
-#ifndef _WIN32
-  [[nodiscard]] pid_t getOutOfProcessExecutorPID() const {
-#ifdef LLVM_BUILT_WITH_OOP_JIT
-    return inner->getOutOfProcessExecutorPID();
-#endif
-    return 0;
-  }
-#endif
-
   /// \returns the \c ExecutorAddr of a given name as written in the object
   /// file.
   llvm::Expected<llvm::orc::ExecutorAddr>