Boosting WebAssembly Performance with Speculative Inlining and Deoptimization in V8

Introduction

WebAssembly execution in Google Chrome just got a significant performance boost. As of Chrome M137, V8 implements two powerful optimizations: speculative call_indirect inlining and deoptimization support for WebAssembly. Together, they enable V8 to generate more efficient machine code by leveraging runtime feedback—a technique long used for JavaScript but only recently applied to WebAssembly. The results are impressive: on Dart microbenchmarks, average speedups exceed 50%, and on larger applications, gains range from 1% to 8%. Beyond immediate performance, deoptimization lays groundwork for future optimizations.

Background: The Role of Speculative Optimization

Speculative optimization is a cornerstone of fast JavaScript execution. Just-in-time (JIT) compilers make assumptions about program behavior based on feedback from earlier runs. For instance, when evaluating a + b, if past executions show both operands are integers, the compiler can emit a fast integer addition instruction. Without such assumptions, it must produce generic, slower code that handles all possible types (strings, floats, objects). If later execution violates these assumptions, V8 performs a deoptimization: it discards the optimized code, resumes with unoptimized code, and collects fresh feedback for possible re-optimization.

For WebAssembly 1.0, speculative optimization wasn't necessary. Wasm programs already enjoy extensive static information—functions, instructions, and variables are all statically typed. Additionally, toolchains like Emscripten (based on LLVM) and Binaryen perform ahead-of-time optimizations typical of C, C++, and Rust compilation. Consequently, the resulting binaries were already well-optimized without runtime speculation.

Motivation: Why Speculation Now?

The landscape changes with WasmGC, the WebAssembly Garbage Collection proposal. WasmGC brings managed languages—Java, Kotlin, Dart—to WebAssembly by supporting high-level constructs like structs, arrays, subtyping, and operations on these types. Unlike the low-level Wasm 1.0 code, WasmGC bytecode is more akin to a high-level intermediate representation, making it a prime candidate for speculative optimizations.

One critical optimization is inlining. Inlining replaces a function call with the function's body directly, eliminating call overhead and enabling further optimizations. However, in a language with polymorphism and indirect calls, the compiler cannot always determine the target at compile time. Speculative inlining uses runtime feedback to guess the most likely target; if the guess is wrong, deoptimization kicks in to correct the path.

Speculative Inlining of call_indirect

The new optimization specifically targets call_indirect instructions in WebAssembly, which are used to invoke functions through an indirect call table. This pattern is common in object-oriented languages where method dispatch is dynamic. In V8's implementation, the compiler observes which function is most frequently called at a given indirect call site. It then speculatively inlines that function's code, assuming the same target will be used again.

To preserve correctness, V8 inserts a guard (a type check) before the inlined code. If the guard fails—meaning a different function is invoked—the code performs a deoptimization, falling back to the original indirect call. This mechanism is analogous to how JavaScript engines handle polymorphic inline caches. The combination of speculative inlining and deoptimization allows V8 to generate fast, type-specialized code for the common case while remaining correct for all cases.

Performance Impact

The benefits are clear across multiple benchmarks:

• Dart microbenchmarks: The combination of speculative inlining and deoptimization yields an average speedup of more than 50%.
• Larger applications: Realistic Dart workloads and other WasmGC benchmarks (e.g., from the Dart/Flutter ecosystem) show improvements between 1% and 8%.

These numbers reflect the advantage of turning dynamic dispatch into direct, inlined calls where possible. Even modest gains in large applications can significantly improve user experience, especially in interactive or real-time contexts.

Conclusion and Future Directions

Speculative inlining and deoptimization mark a step change for WebAssembly optimization in V8. They bring the same dynamism that made JavaScript VMs fast to the WebAssembly world, particularly for WasmGC. Moreover, deoptimization infrastructure opens the door to even more aggressive optimizations. Future work may include speculative monomorphization, loop-invariant code motion based on runtime types, or adaptive compilation strategies.

As WebAssembly continues to evolve, speculative techniques will become increasingly important for achieving peak performance—especially as more high-level languages target WasmGC. Chrome M137 delivers these benefits today, and the V8 team continues to refine and extend the optimization pipeline.