Understanding and Finding JIT Compiler Performance Bugs

• URL: http://arxiv.org/abs/2603.06551v1
• Date: Fri, 06 Mar 2026 18:39:33 GMT
• Title: Understanding and Finding JIT Compiler Performance Bugs
• Abstract summary: Just-in-time (JIT) compilers are key components for many popular programming languages with managed runtimes.<n>JIT compilers might have software bugs, and prior work has developed a number of automated techniques for detecting functional bugs.<n>No prior work has targeted JIT compiler performance bugs, which can cause significant performance degradation while an application is running.
• Score: 11.795888934386175
• License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
• Abstract: Just-in-time (JIT) compilers are key components for many popular programming languages with managed runtimes (e.g., Java and JavaScript). JIT compilers perform optimizations and generate native code at runtime based on dynamic profiling data, to improve the execution performance of the running application. Like other software systems, JIT compilers might have software bugs, and prior work has developed a number of automated techniques for detecting functional bugs (i.e., generated native code does not semantically match that of the original code). However, no prior work has targeted JIT compiler performance bugs, which can cause significant performance degradation while an application is running. These performance bugs are challenging to detect due to the complexity and dynamic nature of JIT compilers. In this paper, we present the first work on demystifying JIT performance bugs. First, we perform an empirical study across four popular JIT compilers for Java and JavaScript. Our manual analysis of 191 bug reports uncovers common triggers of performance bugs, patterns in which these bugs manifest, and their root causes. Second, informed by these insights, we propose layered differential performance testing, a lightweight technique to automatically detect JIT compiler performance bugs, and implement it in a tool called Jittery. We incorporate practical optimizations into Jittery such as test prioritization, which reduces testing time by 92.40% without compromising bug-detection capability, and automatic filtering of false-positives and duplicates, which substantially reduces manual inspection effort. Using Jittery, we discovered 12 previously unknown performance bugs in the Oracle HotSpot and Graal JIT compilers, with 11 confirmed and 6 fixed by developers.

Related papers

• Finding and Understanding Miscompilation Bugs in the Solidity Compiler [0.0]
  We created SolSmith to improve the quality of the Solidity compiler.<n>We have discovered 25 miscompilation bugs that went unnoticed, some for multiple years.<n>We classify miscompilation bugs found by SolSmith based on their nature, root-causes, and impact on end-users.
  arXiv  Detail & Related papers  (2026-07-08T09:59:46Z)
• Interleaving Large Language Models for Compiler Testing [2.4796712345498015]
  Testing compilers with AI models has shown great promise, but current approaches struggle with two key problems.<n>We propose a novel compiler testing framework that decouples the testing process into two distinct phases.<n>In the online phase, we reuse these code pieces by strategically combining them to build high-quality and valid test programs.
  arXiv  Detail & Related papers  (2025-08-26T11:49:58Z)
• CrashFixer: A crash resolution agent for the Linux kernel [58.152358195983155]
  This work builds upon kGym, which shares a benchmark for system-level Linux kernel bugs and a platform to run experiments on the Linux kernel.<n>This paper introduces CrashFixer, the first LLM-based software repair agent that is applicable to Linux kernel bugs.
  arXiv  Detail & Related papers  (2025-04-29T04:18:51Z)
• Finding Missed Code Size Optimizations in Compilers using LLMs [1.90019787465083]
  We develop a novel testing approach which combines large language models with a series of differential testing strategies.<n>Our approach requires fewer than 150 lines of code to implement.<n>To date we have reported 24 confirmed bugs in production compilers.
  arXiv  Detail & Related papers  (2024-12-31T21:47:46Z)
• Java JIT Testing with Template Extraction [7.714591709931207]
  LeJit is a template-based framework for testing Java just-in-time (JIT) compilers. We have successfully used LeJit to test a range of popular Java JIT compilers.
  arXiv  Detail & Related papers  (2024-03-17T17:39:27Z)
• Leveraging Print Debugging to Improve Code Generation in Large Language Models [63.63160583432348]
  Large language models (LLMs) have made significant progress in code generation tasks. But their performance in tackling programming problems with complex data structures and algorithms remains suboptimal. We propose an in-context learning approach that guides LLMs to debug by using a "print debug" method.
  arXiv  Detail & Related papers  (2024-01-10T18:37:59Z)
• DebugBench: Evaluating Debugging Capability of Large Language Models [80.73121177868357]
  DebugBench is a benchmark for Large Language Models (LLMs) It covers four major bug categories and 18 minor types in C++, Java, and Python. We evaluate two commercial and four open-source models in a zero-shot scenario.
  arXiv  Detail & Related papers  (2024-01-09T15:46:38Z)
• Directed Test Program Generation for JIT Compiler Bug Localization [3.626013617212667]
  Bug localization techniques for Just-in-Time (JIT) compilers are based on analyzing the execution behaviors of the target JIT compiler on a set of test programs generated for this purpose. This paper proposes a novel technique for automatic test program generation for JIT compiler bug localization.
  arXiv  Detail & Related papers  (2023-07-17T22:43:02Z)
• A Static Evaluation of Code Completion by Large Language Models [65.18008807383816]
  Execution-based benchmarks have been proposed to evaluate functional correctness of model-generated code on simple programming problems. static analysis tools such as linters, which can detect errors without running the program, haven't been well explored for evaluating code generation models. We propose a static evaluation framework to quantify static errors in Python code completions, by leveraging Abstract Syntax Trees.
  arXiv  Detail & Related papers  (2023-06-05T19:23:34Z)
• BigIssue: A Realistic Bug Localization Benchmark [89.8240118116093]
  BigIssue is a benchmark for realistic bug localization. We provide a general benchmark with a diversity of real and synthetic Java bugs. We hope to advance the state of the art in bug localization, in turn improving APR performance and increasing its applicability to the modern development cycle.
  arXiv  Detail & Related papers  (2022-07-21T20:17:53Z)
• PolyDL: Polyhedral Optimizations for Creation of High Performance DL primitives [55.79741270235602]
  We present compiler algorithms to automatically generate high performance implementations of Deep Learning primitives. We develop novel data reuse analysis algorithms using the polyhedral model. We also show that such a hybrid compiler plus a minimal library-use approach results in state-of-the-art performance.
  arXiv  Detail & Related papers  (2020-06-02T06:44:09Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.