Review feedback

Author: alexcrichton

posts/2024-08-26-webassembly-targets-and-new-on-by-default-features.md renamed to posts/2024-08-26-webassembly-targets-change-in-default-target-features.md

@@ -1,27 +1,59 @@
 ---
 layout: post
-title: "WebAssembly targets and new on-by-default features"
+title: "WebAssembly targets: change in default target-features"
 author: Alex Crichton
+team: The Compiler Team <https://www.rust-lang.org/governance/teams/compiler>
 ---
 
 The Rust compiler has [recently upgraded to using LLVM 19][llvm19] and this
-change accompanies some updates to WebAssembly targets of the Rust compiler.
-Nightly Rust, what will be come Rust 1.82 on 2024-10-17, reflects all of these
-changes and can be used for testing.
+change accompanies some updates to the default set of target features enabled
+for WebAssembly targets of the Rust compiler. Nightly Rust today, which will
+become Rust 1.82 on 2024-10-17, reflects all of these changes and can be
+used for testing.
 
-WebAssembly is an evolving standard where new features are being added over time
-through a [proposals process][proposals]. As WebAssembly proposals reach
+WebAssembly is an evolving standard where extensions are being added over
+time through a [proposals process][proposals]. WebAssembly proposals reach
 maturity, get merged into the specification itself, get implemented in engines,
-and remains this way for quite some time then producer toolchains (e.g. LLVM)
-are going to update to include these new proposals by default. In LLVM 19 this
-has happened with the [multi-value and reference-types proposals][llvmenable].
-These are now enabled by default in LLVM and transitively means that it's
-enabled by default for Rust as well.
+and remain this way for quite some time before producer toolchains (e.g. LLVM)
+update to **enable these sufficiently-mature proposals by default**. In LLVM 19
+this has happened with the [multi-value and reference-types
+proposals][llvmenable] for the LLVM/Rust target features `multivalue` and
+`reference-types`. These are now enabled by default in LLVM and transitively
+means that it's enabled by default for Rust as well.
 
 WebAssembly targets for Rust now [have improved
 documentation](https://github.com/rust-lang/rust/pull/128511) about WebAssembly
-features and disabling them, and this post is going to review these changes and
-go into depth about what's changing in LLVM.
+proposals and their corresponding target features. This post is going to review
+these changes and go into depth about what's changing in LLVM.
+
+## WebAssembly Proposals and Compiler Target Features
+
+WebAssembly proposals are the formal means by which the WebAssembly standard
+itself is evolved over time. Most proposals need toolchain integration in one
+form or another, for example new flags in LLVM or the Rust compiler. The
+`-Ctarget-feature=...` mechanism is used to implement this today. This is a
+signal to LLVM and the Rust compiler which WebAssembly proposals are enabled or
+disabled.
+
+There is a loose coupling between the name of a proposal (often the name of the
+github repository of the proposal) and the feature name LLVM/Rust use. For
+example there is the [`multi-value`
+proposal](https://github.com/webAssembly/multi-value) but a `multivalue`
+feature.
+
+The lifecycle of the implementation of a feature in Rust/LLVM typically looks
+like:
+
+1. A new WebAssembly proposal is created in a new repository, for example
+   WebAssembly/foo.
+2. Eventually Rust/LLVM implement the proposal under `-Ctarget-feature=+foo`
+3. Eventually the upstream proposal is merged into the specification, and
+   WebAssembly/foo becomes an archived repository
+4. Rust/LLVM enable the `-Ctarget-feature=+foo` feature by default but typically
+   retain the ability to disable it as well.
+
+The `reference-types` and `multivalue` target features in Rust are at step (4)
+here now and this post is explaining the consequences of doing so.
 
 ## Enabling Reference Types by Default
 
@@ -31,7 +63,9 @@ new concepts to WebAssembly, notably the `externref` type which is a
 host-defined GC resource that WebAssembly cannot access but can pass around.
 Rust does not have support for the WebAssembly `externref` type and LLVM 19 does
 not change that. WebAssembly modules produced from Rust will continue to not use
-the `externref` type nor have a means of being able to do so.
+the `externref` type nor have a means of being able to do so. This may be
+enabled in the future, but it will mostly likely only be done on an opt-in basis
+and will not affect preexisting code by default.
 
 Also included in the reference-types proposal, however, was the ability to have
 multiple WebAssembly tables in a single module. In the original version of the
@@ -47,9 +81,9 @@ was encoded with a fixed zero byte in its instruction (required to be exactly
 0x00). This fixed zero byte was relaxed to a 32-bit [LEB] to indicate which
 table the `call_indirect` instruction was using. For those unfamiliar [LEB] is a
 way of encoding multi-byte integers in a smaller number of bytes for smaller
-integers. For example the integer 0 can be encoded as `0x00` with a [LEB].
-[LEB]s are flexible to additionally allow "overlong" encodings so the integer 0
-can additionally be encoded as `0x80 0x00`.
+integers. For example the 32-gbit integer 0 can be encoded as `0x00` with a
+[LEB]. [LEB]s are flexible to additionally allow "overlong" encodings so the
+integer 0 can additionally be encoded as `0x80 0x00`.
 
 LLVM's support of separate compilation of source code to a WebAssembly binary
 means that when an object file is emitted it does not know the final index of
@@ -60,29 +94,30 @@ over-long [LEB] of the form `0x80 0x80 0x80 0x80 0x00` which is the maximal
 length of a 32-bit [LEB]. This [LEB] is then filled in by the linker with a
 relocation to the actual table index that is used by the final module.
 
-When putting all of this together it means that LLVM 19, which has
-reference-types enabled by default, then any WebAssembly module with an indirect
-function call (which is almost always the case for Rust code) will produce a
-WebAssembly binary that cannot be decoded by engines and tooling that do not
-support the reference-types proposal. It is expected that this change will have
-a low impact due to the age of the reference-types proposal and breadth of
-implementation in engines. Given the multitude of WebAssembly engines, however,
-it's recommended that any WebAssembly users test out Nightly Rust and see if
-the produced module still runs on the engine of choice.
+When putting all of this together, it means that with LLVM 19, which has
+the `reference-types` feature enabled by default, any WebAssembly module with an
+indirect function call (which is almost always the case for Rust code) will
+produce a WebAssembly binary that cannot be decoded by engines and tooling that
+do not support the reference-types proposal. It is expected that this change
+will have a low impact due to the age of the reference-types proposal and
+breadth of implementation in engines. Given the multitude of WebAssembly
+engines, however, it's recommended that any WebAssembly users test out
+Nightly Rust and see if the produced module still runs on the engine of
+choice.
 
 ### LLVM, Rust, and Multiple Tables
 
-One interesting point worth mentioning is that despite reference-types enabling
-multiple tables in WebAssembly modules this is not actually taken advantage of
-at this time by either LLVM or Rust. WebAssembly modules emitted will still have
-at most one table of functions. This means that the over-long 5-byte encoding of
-index 0 as `0x80 0x80 0x80 0x80 0x00` is not actually necessary at this time.
-LLD, LLVM's linker for WebAssembly, wants to process all [LEB] relocations in a
-similar manner which currently forces this 5-byte encoding of zero. For example
-when a function calls another function the `call` instruction encodes the target
-function index as a 5-byte [LEB] which is filled in by the linker. There is
-quite often more than one function so the 5-byte encoding enables all possible
-function indices to be encoded.
+One interesting point worth mentioning is that despite the reference-types
+proposal enabling multiple tables in WebAssembly modules this is not actually
+taken advantage of at this time by either LLVM or Rust. WebAssembly modules
+emitted will still have at most one table of functions. This means that the
+over-long 5-byte encoding of index 0 as `0x80 0x80 0x80 0x80 0x00` is not
+actually necessary at this time. LLD, LLVM's linker for WebAssembly, wants to
+process all [LEB] relocations in a similar manner which currently forces this
+5-byte encoding of zero. For example when a function calls another function the
+`call` instruction encodes the target function index as a 5-byte [LEB] which is
+filled in by the linker. There is quite often more than one function so the
+5-byte encoding enables all possible function indices to be encoded.
 
 In the future LLVM might start using multiple tables as well. For example LLVM
 may have a mode in the future where there's a table-per-function type instead of
@@ -99,18 +134,19 @@ single byte.
 
 ## Enabling Multi-Value by Default
 
-The second feature enabled by default in LLVM 19 is multi-value. The
+The second feature enabled by default in LLVM 19 is `multivalue`. The
 [multi-value proposal to WebAssembly][multi-value] enables functions to have
 more than one return value for example. WebAssembly instructions are
 additionally allowed to have more than one return value as well. This proposal
 is one of the first to get merged into the WebAssembly specification after the
 original MVP and has been implemented in many engines for quite some time.
 
 The consequences of enabling this feature by default in LLVM are more minor for
-Rust, however, than enabling reference-types by default. LLVM's default ABI for
-WebAssembly code is not changing even when multi-value is enabled. Additionally
-Rust's ABI is not changing either and continues to match LLVM's. Despite this
-though the change has the possibility of still affecting Nightly users of Rust.
+Rust, however, than enabling the `reference-types` feature by default. LLVM's
+default C ABI for WebAssembly code is not changing even when `multivalue` is
+enabled.  Additionally Rust's `extern "C"` ABI is not changing either and
+continues to match LLVM's. Despite this though the change has the possibility
+of still affecting Nightly users of Rust.
 
 Rust for some time has supported an `extern "wasm"` ABI on Nightly which was an
 experimental means of exposing the ability of defining a function in Rust which
@@ -128,6 +164,30 @@ Supporting WebAssembly multi-return functions in Rust is a broader topic than
 this post can cover, but at this time it's an area that's ripe for contribution
 from suitably motivated contributors.
 
+### Aside: ABI Stability and WebAssembly
+
+While on the topics of ABIs and the `multi-value` feature it's perhaps worth
+also going over a bit what ABIs mean for WebAssembly. Currently there's
+effectively only one ABI implemented by LLVM and the Rust compiler meaning that
+at the WebAssembly module level `extern "C"` and `extern "Rust"` are
+more-or-less the same. Despite this though there's no need for this to be true.
+
+The `extern "C"` ABI, what C code uses by default as well, is difficult to
+change because stability is often required across different compiler versions.
+For example WebAssembly code compiled with LLVM 18 might be expected to work
+with code compiled by LLVM 20. This means that changing the ABI is a daunting
+task that requires version fields, explicit markers, etc, to help prevent
+mismatches.
+
+The `extern "Rust"` ABI, however, is entirely within the control of the Rust
+compiler and can change from version to version. Just because it happens to work
+like `extern "C"` today doesn't mean it will continue to do so in the future. A
+great example of this is that when the `multi-value` feature is enabled the
+`extern "Rust"` ABI could be redefined to use the multiple-return-values that
+WebAssembly would then support. This would enable much more efficient returns of
+values larger than 64-bits. Implementing this would require support in LLVM
+though which is not currently present.
+
 ## Enabling Future Proposals to WebAssembly
 
 This is not the first time that a WebAssembly proposal has gone from
@@ -150,7 +210,8 @@ by Nightly Rust and LLVM 19 then your options are:
   either be done on your engine's repository, the Rust repository, or the
   WebAssembly
   [tool-conventions](https://github.com/WebAssembly/tool-conventions)
-  repository.
+  repository. It's recommended to first search to confirm there isn't already an
+  open issue though.
 * Recompile your code with features disabled, more on this in the next section.
 
 The general assumption behind enabling new features by default is that it's a