Inlining: --inline-max-combined-binary-size is not enforced when several functions are inlined into one caller in the same iteration

Abierto
#9,384 0 comentarios 0 reacciones 1 asignado Ver en GitHub

Los mantenedores suelen responder en 1 día

@kripken ya está trabajando en esto.

Desde el 12/11/2026.

  • #9387 de @kripken — abierto

Evaluación

Dificultad
3/5
Tiempo estimado
1-2 días
Aptitud para principiantes
58/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
cpp, wasm

Línea de trabajo

Read src/passes/Inlining.cpp, especially isUnderSizeLimit and the code that selects inlining actions during an iteration. Trace how multiple chosen actions affect a target's combined size, then add or update a regression test for several callees inlined into one caller. Done means the combined-size limit is respected in that case while the single-callee behavior still works.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

Summary

--inline-max-combined-binary-size (default 409600) is not enforced when several functions are inlined into the same caller in one inlining iteration. isUnderSizeLimit in src/passes/Inlining.cpp checks infos[target].size + infos[source].size for each chosen action, using the sizes measured when the iteration started, so every check passes against the caller's original size. With single-caller functions, which --one-caller-inline-max-function-size admits at any size by default, a caller with many such callees absorbs all of them in one round and grows far past the limit.

In a large program compiled from .NET, a dispatch function calling about 3,500 single-caller functions became one 12.3 MB function after -O3. That is over the 7,654,321-byte function body limit that V8 and wasmparser enforce, so the optimized module no longer validates.

Reproduction

gen.py N BODY writes a module whose exported dispatch calls each of N functions exactly once through a br_table. Each callee has that one caller and a straight-line body of about BODY instructions.

import sys
n, body = int(sys.argv[1]), int(sys.argv[2])
out = ["(module", "  (memory 1)"]
for i in range(n):
    lines = [f"  (func $f{i} (param $x i32) (result i32)", "    (local $a i32)", "    (local.set $a (local.get $x))"]
    for j in range(body // 8):
        lines.append(f"    (i32.store offset={(j * 4) % 4096} (local.get $a) (i32.add (i32.mul (local.get $a) (i32.const {i * 31 + j})) (i32.const {j})))")
        lines.append(f"    (local.set $a (i32.xor (local.get $a) (i32.load offset={(j * 8) % 4096} (local.get $a))))")
    lines.append("    (local.get $a))")
    out += lines
blocks = "".join(f"(block $b{i} " for i in range(n))
out.append("  (func $dispatch (export \"dispatch\") (param $k i32) (param $x i32) (result i32)")
out.append("    " + blocks + "(br_table " + " ".join(f"$b{i}" for i in range(n)) + f" $b{n-1} (local.get $k))")
for i in range(n):
    out.append(f"    ) (return (call $f{i} (local.get $x)))")
out.append("  ))")
print("\n".join(out))
python3 gen.py 20 13600 > small.wat
wasm-as small.wat -o small.wasm
wasm-opt small.wasm -O3 -o out.wasm

With wasm-opt version 132 (version_132-8-g8d9412ef6):

Module Functions dispatch body
input: 20 callees of 45,718 bytes each 21 187 bytes
-O3 1 846,018 bytes
-O3 --inline-max-combined-binary-size=409600 1 846,018 bytes

Every callee is inlined, so dispatch ends at about twice the limit. At larger scale (gen.py 3000 400) dispatch grows from 32,752 bytes to 3,601,560 bytes.

The per-inlining check does work for a single large callee: with gen.py 1 140000 (one 489,862-byte callee) the callee is left as a call.

Expected

Inlining into dispatch stops once the combined size reaches the limit, after about eight callees here, and the remaining callees stay as calls.

Possible fix

Account for the inlinings already chosen for a target in the same iteration: for example, keep a running size per target that each chosen action adds to, and check against it in isUnderSizeLimit, or update infos[target].size when an action is chosen. isUnderSizeLimit is unchanged on main.

As a workaround we mark the excess callees never-inline (@metadata.code.inline 0) before running wasm-opt.

Lenguaje dominante
WebAssembly
Estrellas
8.7k
Forks
913
Merge medio
2 d 14 h
PR fusionados (30 d)
92

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de WebAssembly/binaryen

Todos los issues de WebAssembly/binaryen

Issues similares

Más issues de Compilers

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.