- 18

LLVM version 18 is required. Both `clang` and `llvm-readobj` need to be installed and discoverable (version suffixes, like `clang-18`, are okay). It's highly recommended that you also have `llvm-objdump` available, since this allows the build script to dump human-readable assembly for the generated code.

Install LLVM 18 on Ubuntu/Debian:

sudo ./llvm.sh 18

Install LLVM 18 on Fedora Linux 40 or newer:

sudo dnf install 'clang(major) = 18' 'llvm(major) = 18'

Install LLVM 18 with [Homebrew](https://brew.sh):

brew install llvm@18

Install LLVM 18 [by searching for it on LLVM's GitHub releases page](https://github.com/llvm/llvm-project/releases?q=18), clicking on "Assets", downloading the appropriate Windows installer for your platform (likely the file ending with `-win64.exe`), and running it. **When installing, be sure to select the option labeled "Add LLVM to the system PATH".**

choco install llvm --version=18.1.6

If you are working CPython in a [Codespaces instance](https://devguide.python.org/getting-started/setup-building/#using-codespaces), there's no need to install LLVM as the Fedora 40 base image includes LLVM 18 out of the box.

_LLVM_VERSION = 18

def fold(self, other: typing.Self) -> typing.Self | None:

ghccc: bool = False

# The trampoline's entry point is just named "_ENTRY", since on some

# platforms we later assume that any function starting with "_JIT_" uses

# the GHC calling convention:

entry_symbol = "_JIT_ENTRY" if "_JIT_ENTRY" in group.symbols else "_ENTRY"

assert group.symbols[entry_symbol] == (_stencils.HoleValue.CODE, 0)

# "Compile" the trampoline to an empty stencil group if it's not needed:

if opname == "trampoline" and not self.ghccc:

return _stencils.StencilGroup()

if self.ghccc:

# This is a bit of an ugly workaround, but it makes the code much

# smaller and faster, so it's worth it. We want to use the GHC

# calling convention, but Clang doesn't support it. So, we *first*

# compile the code to LLVM IR, perform some text replacements on the

# IR to change the calling convention(!), and then compile *that*.

# Once we have access to Clang 19, we can get rid of this and use

# __attribute__((preserve_none)) directly in the C code instead:

ll = tempdir / f"{opname}.ll"

args_ll = args + [

# -fomit-frame-pointer is necessary because the GHC calling

# convention uses RBP to pass arguments:

"-S",

"-emit-llvm",

"-fomit-frame-pointer",

"-o",

f"{ll}",

f"{c}",

]

await _llvm.run("clang", args_ll, echo=self.verbose)

ir = ll.read_text()

# This handles declarations, definitions, and calls to named symbols

# starting with "_JIT_":

ir = re.sub(

r"(((noalias|nonnull|noundef) )*ptr @_JIT_\w+\()", r"ghccc \1", ir

)

# This handles calls to anonymous callees, since anything with

# "musttail" needs to use the same calling convention:

ir = ir.replace("musttail call", "musttail call ghccc")

# Sometimes *both* replacements happen at the same site, so fix it:

ir = ir.replace("ghccc ghccc", "ghccc")

ll.write_text(ir)

args_o = args + ["-Wno-unused-command-line-argument", "-o", f"{o}", f"{ll}"]

else:

args_o = args + ["-o", f"{o}", f"{c}"]

await _llvm.run("clang", args_o, echo=self.verbose)

# ghccc currently crashes Clang when combined with musttail on aarch64. :(

args = ["-DPy_NO_ENABLE_SHARED"]

target = _COFF(host, args=args, ghccc=True, prefix="_")

target = _MachO(host, ghccc=True, prefix="_")

target = _COFF(host, args=args, ghccc=True)

target = _ELF(host, args=args, ghccc=True)

if pair and (folded := hole.fold(pair)):

return ((jit_func)((EXECUTOR)->jit_side_entry))(frame, stack_pointer, tstate); \

return ((jit_func)&ALIAS)(frame, stack_pointer, tstate); \

_Py_CODEUNIT *

_ENTRY(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer, PyThreadState *tstate)

_Py_CODEUNIT *target = ((jit_func)&_JIT_CONTINUE)(frame, stack_pointer, tstate);