[wasm] Carry R2R function names in a name section, not the export table

[lewing]

Fixes #132905.

WebCilObjectWriter.WriteExports exported every defined function. At framework scale that produces a module no conforming engine will load, because exports count towards the engine's effective-type-size limit.

Measured over the full wasi-wasm framework closure (181 assemblies + corelib), with function count identical either side so the export section is the only variable:

	functions	exports	export section	wasm-tools validate
before	232,673	232,675	29.0 MB	❌ effective type size exceeds the limit of 1000000
after	232,673	4	65 bytes	✅ valid

wasmtime rejects the "before" image identically — both use wasmparser underneath. The limit is reached somewhere around 160,000 exported functions, so a small composite is unaffected and only framework-sized ones fail.

Why the exports were there, and why nothing needs them

The V0 writer exported bodies "so that the resulting module can be loaded and method bodies can be called by an external loader" (#122111). But WriteElements() — immediately below WriteExports() — already emits an element segment over all function indices, and that, not the export table, is what makes a function reachable. There was a TODO-WASM: Handle exports better sitting above the loop.

Exports do not participate in call resolution

Worth stating explicitly, since it is the obvious objection:

• A direct call takes a function index, not a name, so intra-module calls are unaffected by the export table.
• A cross-module call appears as a function import in the calling module, resolved against the provider's exports. Neither a composite nor a single-assembly image has any function imports — both carry the same seven: four globals, a table, a tag, and memory. There is nothing to pair.
• Exports matter only when something outside looks a function up by name: a host at instantiation, or wasm-merge pairing an import to an export. The stubs that serve that purpose are kept.

Cross-module linkage is the shared table, not imports. Every image is instantiated against the host's single table with its own tableBase, its functions are installed into that slice, and a cross-assembly call resolves through an R2R fixup cell to an absolute table index dispatched by call_indirect. That mechanism is identical in composite and non-composite builds; only the number of modules sharing the table differs.

The one mechanism by which removing exports could invalidate a module is ref.func, which requires its target to be "declared" — via an export, a global initializer, or an element segment. That is not in play on two independent counts: these images contain no ref.func at all, and the element segment already declares every function regardless.

For reference, R2R wasm today emits no direct calls whatsoever. A census over decoded WAT finds 0 call and 202,143 call_indirect in a 56,790-function composite, and 0 call in single-assembly images as well. That is context rather than a dependency: the reasoning above holds either way.

Also verified that neither JS loader reads per-function exports (fillWebcilTable is table.init over the element segment), nor does WebcilImageReader or r2rdump.

The catch, and the reason this is not just a deletion

crossgen2 emits no custom sections, so the export names were the only record of function names — wasm-merge -g synthesizes a merged module's name section from them. Simply dropping the exports would leave every composite frame anonymous in a debugger.

So this emits a name custom section instead. It is ignored by engines, counts towards no limit, and can be stripped when size matters — which is the only arrangement that gets loadable-at-scale, named, and small at the same time.

Only the stubs the host actually calls are exported now. Stub names are recorded at InsertWasmStub, so the export set is derived rather than hardcoded.

Effect by image kind

image	functions	exports	name section
composite	52,693	4	4.8 MB
component stub	3	5 — unchanged	53 B
single-assembly	31	4	2 KB

Component stubs are unaffected, since all of their functions are stubs.

Validation

• Reproduced the failure before fixing it, so the pass distinguishes something.
• Name section verified index-sorted, duplicate-free, contiguous over the defined-function range, no trailing bytes, by three independent parsers (wasm-tools validate, wasm-tools print resolving $getWebcilSize, and a standalone scanner).
• Browser end-to-end in both composite and non-composite modes, each against a control with R2R disabled and, for composite, a stale-stub control. R2R-active runs at 5 ms against 112–119 ms interpreted, with identical program output. A passing run alone would not have shown R2R was used — a stale stub still logs Ready to Run initialized successfully while running fully interpreted — so the timing separation is what carries it.
• The non-composite run is the sharpest evidence that exports are not the linkage mechanism: System.Private.CoreLib goes from 52,454 functions to 5 exports, and the other images still call into it. Its per-module R2R log is byte-identical to the pre-change baseline.
• ILCompiler.ReadyToRun.Tests: 55/0 for TargetOS=browser, 85/0 for the default target.

The second commit addresses review feedback: the payload was built through chained MemoryStreams and a final ToArray(), so it is now sized in one pass and streamed to the output. The emitted bytes are unchanged — the name section is byte-identical before and after the rewrite, confirmed by sha256 over the 28 MB framework-scale section. No memory measurement is claimed: peak RSS at framework scale is dominated by crossgen2's ~2.7 GiB compilation working set, and run-to-run spread there is wider than the effect, so RSS is the wrong instrument.

Test change

CheckFunctionExports asserted that exports cover every defined function — the invariant being removed. It is replaced by a stronger one: the name section must name every defined function, and index i must equal importedFunctionCount + i.

The exact-index requirement is deliberate. Count, ordering, uniqueness and a lower bound are all relational properties that a uniformly shifted map satisfies, so only an absolute anchor excludes an off-by-one — which is exactly the failure mode a name section has to be trusted not to have. Confirmed by negative controls: suppressing the name section, and emitting Index + 1, each fail the test with a specific diagnostic.

Note

This pull request description was generated by GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 4 pipeline(s).
12 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to 'arch-wasm': @lewing, @pavelsavara
See info in area-owners.md if you want to be subscribed.

[azure-pipelines]

Azure Pipelines:
Successfully started running 4 pipeline(s).
12 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[Copilot]

Pull request overview

This PR addresses WebAssembly engine validation failures at framework scale by stopping the WebCil wasm object writer from exporting every defined function (which bloats the export section and can exceed effective type-size limits). Instead, it preserves function names by emitting a name custom section and restricts the export table to only the small set of host-called stub functions.

Changes:

• Emit a wasm name custom section containing function names for all defined functions.
• Export only writer-inserted stub functions (tracked at stub insertion time) rather than all functions.
• Update ReadyToRun wasm assertions to validate the name section mapping, and document the new constraint.

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
src/coreclr/tools/Common/Compiler/ObjectWriter/WebCilObjectWriter.cs	Appends a name section at the end of the module; limits function exports to host-called stubs.
src/coreclr/tools/Common/Compiler/ObjectWriter/WasmObjectWriter.cs	Tracks writer-inserted stub names to drive the reduced export set.
src/coreclr/tools/Common/Compiler/ObjectWriter/Wasm/WasmNameSection.cs	Implements emission of the name custom section’s function-name subsection.
src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj	Includes the new WasmNameSection.cs in the ReadyToRun tool build.
src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCasesRunner/WasmR2RAssert.cs	Reworks tests to assert stub-only exports and validate the name section covers defined functions correctly.
docs/design/mono/webcil.md	Documents that compiled method bodies should not be exported en masse; names live in the name section.