Stream: git-wasmtime

Topic: wasmtime / issue #4185 Tracking issue for implementing th...

Wasmtime GitHub notifications bot (May 24 2022 at 18:04):

alexcrichton labeled issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:04):

alexcrichton opened issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:04):

alexcrichton labeled issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:04):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:11):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:12):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 18:14):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [ ] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 24 2022 at 19:48):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 25 2022 at 18:26):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 28 2022 at 19:17):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 28 2022 at 20:16):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Calling a function with a "dynamic" signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 31 2022 at 00:44):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for memory64 in adapters and such
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 31 2022 at 16:12):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 31 2022 at 16:12):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (May 31 2022 at 21:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 01 2022 at 20:00):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 03 2022 at 15:33):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [ ] Importing a wasm module into a component
• [ ] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 03 2022 at 15:34):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 03 2022 at 15:35):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 03 2022 at 15:35):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 06 2022 at 16:22):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [ ] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 14:46):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [ ] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 14:46):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 14:46):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 16:00):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 17:47):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 17:55):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 07 2022 at 17:55):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components

Wasmtime GitHub notifications bot (Jun 17 2022 at 15:45):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 15:48):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 18:09):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 18:09):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 18:09):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 18:09):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 17 2022 at 18:09):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [ ] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 18:16):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [ ] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 18:16):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [ ] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 18:16):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [ ] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 18:16):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 19:54):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 21 2022 at 19:54):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 19:57):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 19:58):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Post-return functions
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with reexporting an imported function
• [ ] Figure out what to do with lowering a lifted function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Figure out what to do with reexporting an imported function
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [x] Implement may_enter and may_leave flags
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:43):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Exporting a component instance from the root of a component

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:44):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:44):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 20:44):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 22 2022 at 21:42):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 23 2022 at 18:35):

fitzgen edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [ ] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Fuzz interface functions: https://github.com/bytecodealliance/wasmtime/issues/4307

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 23 2022 at 19:37):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Support for record types
• [ ] Support for variant types
• [ ] Support for enum types
• [ ] Support for union types
• [ ] Support for flags types
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Fuzz interface functions: https://github.com/bytecodealliance/wasmtime/issues/4307

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 23 2022 at 21:46):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)
• [ ] Fuzz interface functions: https://github.com/bytecodealliance/wasmtime/issues/4307

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Calling a function with a dynamic signature
• Defining a host function with a dynamic signature
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 23 2022 at 21:52):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 23 2022 at 21:57):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Implement components with 64-bit memories

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 27 2022 at 15:39):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 27 2022 at 16:26):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 27 2022 at 16:26):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 27 2022 at 16:26):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 27 2022 at 16:26):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with lowering a lifted function
• [ ] Validate alignment and enable &[u64] views and similar
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 15:24):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [ ] Figure out what to do with lowering a lifted function
• [x] Validate alignment and enable &[u64] views and similar
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 15:25):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [ ] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 15:25):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 18:37):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Figure out what to do with reexporting an imported function
• [ ] Exporting a component instance from the root of a component
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 18:37):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Figure out what to do with reexporting an imported function
• [ ] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 18:38):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Figure out what to do with reexporting an imported function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 18:38):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Figure out what to do with reexporting an imported function
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 19:11):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Figure out what to do with reexporting an imported function
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level

Wasmtime GitHub notifications bot (Jun 28 2022 at 20:08):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Figure out what to do with reexporting an imported function
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 28 2022 at 20:13):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Figure out what to do with a lifting a lowered function
• [ ] Figure out what to do with reexporting an imported function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 29 2022 at 15:32):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [ ] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 29 2022 at 15:32):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature

Items related to memory64 support

• Need to call realloc with a different signature
• All reads/writes of pointers to linear memory need to have a 32/64 bit switch
• Reading and writing pointers to ValRaw needs to be audited
• Size and alignment calculations all need to be duplicated or have a parameter for 64 bit
• Somehow should probably confirm that this doesn't vastly affect performance for 32-bit

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 29 2022 at 16:05):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 29 2022 at 17:06):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [ ] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jun 29 2022 at 21:46):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [ ] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 01 2022 at 19:24):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 05 2022 at 14:59):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [ ] Fill out unimplemented! for outer core aliases
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 05 2022 at 19:37):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [ ] Fill out unimplemented! for outer core aliases
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 11 2022 at 15:35):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [ ] Fill out unimplemented! for outer core aliases
• [ ] Implement new reentrance rules
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 11 2022 at 15:35):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [x] Fill out unimplemented! for outer core aliases
• [ ] Implement new reentrance rules
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [ ] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.

Wasmtime GitHub notifications bot (Jul 11 2022 at 23:38):

Jeffwan commented on issue #4185:

Hi, do we have a rough estimate on the component-model release? I am trying to understand even there's some pending items, is it working now? Is there a quickstart guidance on the usage?

Wasmtime GitHub notifications bot (Jul 12 2022 at 13:07):

alexcrichton commented on issue #4185:

There's no esimate at this time. Some parts work but not all, the un-finished issues above should give an idea of how much is left to do. No documentation on usage yet.

Wasmtime GitHub notifications bot (Jul 13 2022 at 16:27):

alexcrichton edited issue #4185:

This is intended to be a tracking issue for the implementation of the component model proposal of WebAssembly. I'm in the progress of implementing this with work in Wasmtime starting at https://github.com/bytecodealliance/wasmtime/pull/4005 and continuing in further PRs. I hope to leave checkbox items here to ensure I don't forget about them and to also track the progress of implementing the component model.

Items to be implemented

• [x] Text format parsing
• [x] Validation in wasmparser
• [x] Basic infrastructure in the component submodule of the wasmtime crate
• [x] Basic instantiation with zero imports
• [x] Extracting a function and calling it with a static signature
• [x] Importing host functions into a component
• [x] Importing host instances (bundles of host functions) into a component
• [x] Importing a wasm module into a component
• [x] Exporting a module from a component
• [x] Nested component compilation
• [x] Nested component instantiation
• [x] Outer component aliases
• [x] Exporting a component from a component
• [x] Confirm lowered-then-lifted interpretation of "always trap" is correct
• [x] Split ComponentValue into lifting and lowering traits
• [x] Implement may_enter and may_leave flags
• [x] Post-return functions
• [x] Validate alignment and enable &[u64] views and similar
• [x] Figure out what to do with lowering a lifted function
• [x] Double-check behavior of traps with respect to validating in-bounds pointers and intermediate writes of params/results when lifting/lowering given the "trap lock" I don't think that this matters
• [x] Figure out what to do with a lifting a lowered function
• [x] Figure out what to do with reexporting an imported function
• [x] Implement a "lock" for instances for when a trap happens (https://github.com/WebAssembly/component-model/issues/55)
• [x] Exporting a component instance from the root of a component
• [x] Fill out unimplemented! for outer core aliases
• [ ] Implement new reentrance rules
• [ ] Component-to-component adapters (this is a huge work item implying an entire compiler for adapter trampolines)

Separate work items

I'm starting to separate off work items from this issue to separate tracking issues with more detail. These will all need completion to finish the component model work but these issues are suitable to be picked up by anyone in theory.

• [x] Support for record, variant, enum, union, flags
• [ ] Fuzzing for round-tripping component values
• [ ] String support for utf16+latin1 (omitted from #4039)
• [ ] Calling a function with a dynamic signature
• [ ] Support 64-bit memories for components

Unsure how to implement so far

• Everything with value ranging from imports to exports to the start function
• Type imports
• Unsure how to rationalize performance concerns with validating indirect values like lists from wasm coming to the host when balanced with spec-desired behavior of validating everything.

Open questions

• How to optimize passing &[u8] to WebAssembly to a memcpy?
• How to handle validation of Value<T> coming out of wasm?

Not planned at this time

• Importing component-defined functions into a component without any extra copies to the host
• Importing component instances directly into other components
• Importing a component or exporting a component at the root level
• Reexporting an imported function from a component and expecting it to work.