Jeandle: How Ant Group’s LLVM‑Based JVM JIT Aims to Supercharge Java

Jeandle Overview

Jeandle is an open‑source Just‑In‑Time (JIT) compiler for the OpenJDK HotSpot JVM. It replaces the traditional interpreter for hot Java methods with a compiler that generates native machine code using the LLVM compiler infrastructure. By integrating LLVM, Jeandle inherits a powerful optimizer and a modular code‑generation pipeline.

JIT Compilation in the JVM

When a Java program runs, the JVM initially interprets bytecode, which is portable but relatively slow. The interpreter monitors execution frequencies; once a method becomes “hot” (executed many times), the JIT compiler is invoked. The JIT translates the bytecode of that method into an intermediate representation, applies aggressive optimizations, and emits optimized native instructions. This reduces interpretation overhead and improves throughput for long‑running workloads.

LLVM Basics

LLVM provides a three‑stage compilation model:

Front‑end: source language is translated into LLVM IR (Intermediate Representation).

Optimizer: LLVM’s suite of analyses and transformations refines the IR (e.g., dead‑code elimination, loop unrolling, inlining).

Back‑end: target‑specific code generators emit machine code for x86‑64, AArch64, etc.

Why LLVM for a JVM JIT

High‑performance optimizations : LLVM includes industry‑leading analyses such as scalar replacement, vectorization, and profile‑guided optimizations.

Modular design : Individual passes can be selected or extended, allowing a JIT to tailor the optimization pipeline to Java’s semantics.

Rich ecosystem : Existing LLVM front‑ends (Rust, Swift) and a large community provide reusable components and continuous improvements.

Technical Goals and Roadmap

End of 2025 – Full bytecode support : Implement complete Java Virtual Machine specifications, including exception handling, garbage‑collection interaction, and synchronized blocks, so that any valid class file can be compiled and executed.

2026 – Performance‑focused extensions :

Develop a Java‑specific optimization suite (lock‑elimination, escape analysis, advanced method inlining).

Introduce intrinsics for frequently used library methods to replace generic code with hand‑written assembly.

Support On‑Stack Replacement (OSR) to recompile running methods with newer optimizations.

Provide compatibility with the G1 garbage collector, ensuring safe interaction between compiled code and the JVM’s GC.

Key Technical Challenges

Seamless integration with the JVM’s garbage‑collection mechanisms while preserving safety and pause‑time guarantees.

Mapping Java’s dynamic features (e.g., synchronized, reflection) to LLVM constructs without sacrificing correctness.

Designing Java‑aware optimization passes that respect the language’s memory model and concurrency semantics.

Project Repository

https://github.com/jeandle/jeandle-jdk

https://github.com/jeandle/jeandle-ll