Add support for v128 to the typed function API
#7010
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This commit adds a Rust type `V128` which corresponds to the wasm `v128` type. This is intended to perhaps one day have accessors for lanes of various sizes but in the meantime only supports conversion back and forth between `u128`. The intention of this type is to allow platforms to perform typed between to functions that take or return `v128` wasm values. Previously this was not implemented because it's a bit tricky ABI-wise. Typed functions work by passing arguments in registers which requires the calling convention to match in both Cranelift and in Rust. This should be the case for supported platforms and the default calling convention, especially now that the wasm calling convention is separate from the platform calling convention. This does mean, however, that this feature can only be supported on x86_64 and AArch64. Currently neither s390x nor RISC-V have a means of supporting the vector calling convention since the vector types aren't available on stable in Rust itself. This means that it's now unfortunately possible to write a Wasmtime embedding that compiles on x86_64 that doesn't compile on s390x for example, but given how niche this feature is that seems like an ok tradeoff for now and by the time it's a problem Rust might have native stable support for vector types on these platforms. prtest:full
github-actions
bot
added
fuzzing
Subscribe to Label Actioncc @fitzgen, @peterhuene
This issue or pull request has been labeled: "fuzzing", "wasmtime:api", "wasmtime:c-api"
Thus the following users have been cc'd because of the following labels:
To subscribe or unsubscribe from this label, edit the |
fitzgen
approved these changes
Sep 13, 2023
Comment on lines
+54
to
+57
| union Reinterpret { | ||
| abi: Abi, | ||
| u128: u128, | ||
| } |
|
I should also mention before I forget, it is theoretically possible to support v128 on all platforms. We are in control of our own ABI and we could say that the v128 type always maps to memory or a pair of u64 values. This would require rejiggering not only the Cranelift trampolines generated but additionally the |
eduardomourar
pushed a commit
to eduardomourar/wasmtime
that referenced
this pull request
Sep 15, 2023
* Add support for `v128` to the typed function API This commit adds a Rust type `V128` which corresponds to the wasm `v128` type. This is intended to perhaps one day have accessors for lanes of various sizes but in the meantime only supports conversion back and forth between `u128`. The intention of this type is to allow platforms to perform typed between to functions that take or return `v128` wasm values. Previously this was not implemented because it's a bit tricky ABI-wise. Typed functions work by passing arguments in registers which requires the calling convention to match in both Cranelift and in Rust. This should be the case for supported platforms and the default calling convention, especially now that the wasm calling convention is separate from the platform calling convention. This does mean, however, that this feature can only be supported on x86_64 and AArch64. Currently neither s390x nor RISC-V have a means of supporting the vector calling convention since the vector types aren't available on stable in Rust itself. This means that it's now unfortunately possible to write a Wasmtime embedding that compiles on x86_64 that doesn't compile on s390x for example, but given how niche this feature is that seems like an ok tradeoff for now and by the time it's a problem Rust might have native stable support for vector types on these platforms. prtest:full * Fix compile of C API * Conditionally enable typed v128 tests * Review comments * Fix compiler warnings
eduardomourar
pushed a commit
to eduardomourar/wasmtime
that referenced
this pull request
Sep 22, 2023
* Add support for `v128` to the typed function API This commit adds a Rust type `V128` which corresponds to the wasm `v128` type. This is intended to perhaps one day have accessors for lanes of various sizes but in the meantime only supports conversion back and forth between `u128`. The intention of this type is to allow platforms to perform typed between to functions that take or return `v128` wasm values. Previously this was not implemented because it's a bit tricky ABI-wise. Typed functions work by passing arguments in registers which requires the calling convention to match in both Cranelift and in Rust. This should be the case for supported platforms and the default calling convention, especially now that the wasm calling convention is separate from the platform calling convention. This does mean, however, that this feature can only be supported on x86_64 and AArch64. Currently neither s390x nor RISC-V have a means of supporting the vector calling convention since the vector types aren't available on stable in Rust itself. This means that it's now unfortunately possible to write a Wasmtime embedding that compiles on x86_64 that doesn't compile on s390x for example, but given how niche this feature is that seems like an ok tradeoff for now and by the time it's a problem Rust might have native stable support for vector types on these platforms. prtest:full * Fix compile of C API * Conditionally enable typed v128 tests * Review comments * Fix compiler warnings
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This commit adds a Rust type
V128which corresponds to the wasmv128type. This is intended to perhaps one day have accessors for lanes of various sizes but in the meantime only supports conversion back and forth betweenu128. The intention of this type is to allow platforms to perform typed between to functions that take or returnv128wasm values.Previously this was not implemented because it's a bit tricky ABI-wise. Typed functions work by passing arguments in registers which requires the calling convention to match in both Cranelift and in Rust. This should be the case for supported platforms and the default calling convention, especially now that the wasm calling convention is separate from the platform calling convention. This does mean, however, that this feature can only be supported on x86_64 and AArch64. Currently neither s390x nor RISC-V have a means of supporting the vector calling convention since the vector types aren't available on stable in Rust itself. This means that it's now unfortunately possible to write a Wasmtime embedding that compiles on x86_64 that doesn't compile on s390x for example, but given how niche this feature is that seems like an ok tradeoff for now and by the time it's a problem Rust might have native stable support for vector types on these platforms.
prtest:full