Package component model options in an index (#11324)

* Package component model options in an index

This commit is a refactoring of how canonical ABI options are handled
during compilation and runtime. Previously options were "exploded"
meaning that options were all passed around as parameters but this was a
bummer for a few reasons:

* This is `unsafe`-prone as options have raw pointers such as memory and
  functions. This meant that all functions/operations working with
  options were fundamentally `unsafe`.

* This was unwieldy as the set of options continues to grow larger over
  time. The `VMLoweringCallee` function previously had 10+ parameters,
  most of which were canonical ABI options.

To solve these two problems options are now intern'd at compile time to
an `OptionsIndex`, a 32-bit value. This is stored as a new table in
component metadata and consulted at runtime. This means that
`OptionsIndex` can be passed around with an instance for a much safer
means of threading options around. Additionally there's no need to pass
around all parameters individually and instead just one parameter,
`OptionsIndex`, need be threaded through.

This commit additionally overhauls trampoline generation for the
component compiler to avoid a function-per-intrinsic and instead have a
single function that all intrinsics use. I found this easier to
understand and helps codify that all intrinsics are basically the same
with some minor details differing between them.

The end result of this is (hopefully) a net simplification of the
component compiler in addition to a large amount of removal of `unsafe`
code in the async implementation as only safe types are passed around
now instead of raw pointers.

Closes #10143
Closes #11188

* Fill out some TODO comments

Author: alexcrichton

crates/cranelift/src/compiler/component.rs

@@ -100,15 +100,15 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             backpressure_set(vmctx: vmctx, caller_instance: u32, enabled: u32) -> bool;
             #[cfg(feature = "component-model-async")]
-            task_return(vmctx: vmctx, ty: u32, memory: ptr_u8, string_encoding: u8, storage: ptr_u8, storage_len: size) -> bool;
+            task_return(vmctx: vmctx, ty: u32, options: u32, storage: ptr_u8, storage_len: size) -> bool;
             #[cfg(feature = "component-model-async")]
             task_cancel(vmctx: vmctx, caller_instance: u32) -> bool;
             #[cfg(feature = "component-model-async")]
             waitable_set_new(vmctx: vmctx, caller_instance: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            waitable_set_wait(vmctx: vmctx, caller_instance: u32, async_: u8, memory: ptr_u8, set: u32, payload: u32) -> u64;
+            waitable_set_wait(vmctx: vmctx, options: u32, set: u32, payload: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            waitable_set_poll(vmctx: vmctx, caller_instance: u32, async_: u8, memory: ptr_u8, set: u32, payload: u32) -> u64;
+            waitable_set_poll(vmctx: vmctx, options: u32, set: u32, payload: u32) -> u64;
             #[cfg(feature = "component-model-async")]
             waitable_set_drop(vmctx: vmctx, caller_instance: u32, set: u32) -> bool;
             #[cfg(feature = "component-model-async")]
@@ -134,15 +134,15 @@ macro_rules! foreach_builtin_component_function {
                 storage_len: size
             ) -> bool;
             #[cfg(feature = "component-model-async")]
-            sync_start(vmctx: vmctx, callback: ptr_u8, callee: ptr_u8, param_count: u32, storage: ptr_u8, storage_len: size) -> bool;
+            sync_start(vmctx: vmctx, callback: ptr_u8, storage: ptr_u8, storage_len: size, callee: ptr_u8, param_count: u32) -> bool;
             #[cfg(feature = "component-model-async")]
             async_start(vmctx: vmctx, callback: ptr_u8, post_return: ptr_u8, callee: ptr_u8, param_count: u32, result_count: u32, flags: u32) -> u64;
             #[cfg(feature = "component-model-async")]
             future_new(vmctx: vmctx, ty: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            future_write(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, async_: u8, ty: u32, future: u32, address: u32) -> u64;
+            future_write(vmctx: vmctx, ty: u32, options: u32, future: u32, address: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            future_read(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, async_: u8, ty: u32, future: u32, address: u32) -> u64;
+            future_read(vmctx: vmctx, ty: u32, options: u32, future: u32, address: u32) -> u64;
             #[cfg(feature = "component-model-async")]
             future_cancel_write(vmctx: vmctx, ty: u32, async_: u8, writer: u32) -> u64;
             #[cfg(feature = "component-model-async")]
@@ -154,9 +154,9 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             stream_new(vmctx: vmctx, ty: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            stream_write(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, async_: u8, ty: u32, stream: u32, address: u32, count: u32) -> u64;
+            stream_write(vmctx: vmctx, ty: u32, options: u32, stream: u32, address: u32, count: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            stream_read(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, async_: u8, ty: u32, stream: u32, address: u32, count: u32) -> u64;
+            stream_read(vmctx: vmctx, ty: u32, options: u32, stream: u32, address: u32, count: u32) -> u64;
             #[cfg(feature = "component-model-async")]
             stream_cancel_write(vmctx: vmctx, ty: u32, async_: u8, writer: u32) -> u64;
             #[cfg(feature = "component-model-async")]
@@ -166,13 +166,13 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             stream_drop_readable(vmctx: vmctx, ty: u32, reader: u32) -> bool;
             #[cfg(feature = "component-model-async")]
-            flat_stream_write(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, async_: u8, ty: u32, payload_size: u32, payload_align: u32, stream: u32, address: u32, count: u32) -> u64;
+            flat_stream_write(vmctx: vmctx, ty: u32, options:u32, payload_size: u32, payload_align: u32, stream: u32, address: u32, count: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            flat_stream_read(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, async_: u8, ty: u32, payload_size: u32, payload_align: u32, stream: u32, address: u32, count: u32) -> u64;
+            flat_stream_read(vmctx: vmctx, ty: u32, options: u32, payload_size: u32, payload_align: u32, stream: u32, address: u32, count: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            error_context_new(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, ty: u32, debug_msg_address: u32, debug_msg_len: u32) -> u64;
+            error_context_new(vmctx: vmctx, ty: u32, options: u32, debug_msg_address: u32, debug_msg_len: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            error_context_debug_message(vmctx: vmctx, memory: ptr_u8, realloc: ptr_u8, string_encoding: u8, ty: u32, err_ctx_handle: u32, debug_msg_address: u32) -> bool;
+            error_context_debug_message(vmctx: vmctx, ty: u32, options: u32, err_ctx_handle: u32, debug_msg_address: u32) -> bool;
             #[cfg(feature = "component-model-async")]
             error_context_drop(vmctx: vmctx, ty: u32, err_ctx_handle: u32) -> bool;
             #[cfg(feature = "component-model-async")]
@@ -186,7 +186,7 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             context_set(vmctx: vmctx, slot: u32, val: u32) -> bool;
 
-            trap(vmctx: vmctx, code: u8);
+            trap(vmctx: vmctx, code: u8) -> bool;
 
             utf8_to_utf8(vmctx: vmctx, src: ptr_u8, len: size, dst: ptr_u8) -> bool;
             utf16_to_utf16(vmctx: vmctx, src: ptr_u16, len: size, dst: ptr_u16) -> bool;

crates/environ/src/component.rs

@@ -138,6 +138,10 @@ pub struct ComponentDfg {
     /// of this component by idnicating what order operations should be
     /// performed during instantiation.
     pub side_effects: Vec<SideEffect>,
+
+    /// Interned map of id-to-`CanonicalOptions`, or all sets-of-options used by
+    /// this component.
+    pub options: Intern<OptionsId, CanonicalOptions>,
 }
 
 /// Possible side effects that are possible with instantiating this component.
@@ -211,6 +215,7 @@ id! {
     pub struct AdapterId(u32);
     pub struct PostReturnId(u32);
     pub struct AdapterModuleId(u32);
+    pub struct OptionsId(u32);
 }
 
 /// Same as `info::InstantiateModule`
@@ -229,7 +234,7 @@ pub enum Export {
     LiftedFunction {
         ty: TypeFuncIndex,
         func: CoreDef,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     ModuleStatic {
         ty: ComponentCoreModuleTypeId,
@@ -300,7 +305,7 @@ impl<T> CoreExport<T> {
 pub enum Trampoline {
     LowerImport {
         import: RuntimeImportIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
         lower_ty: TypeFuncIndex,
     },
     Transcoder {
@@ -319,7 +324,7 @@ pub enum Trampoline {
     },
     TaskReturn {
         results: TypeTupleIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     TaskCancel {
         instance: RuntimeComponentInstanceIndex,
@@ -328,14 +333,10 @@ pub enum Trampoline {
         instance: RuntimeComponentInstanceIndex,
     },
     WaitableSetWait {
-        instance: RuntimeComponentInstanceIndex,
-        async_: bool,
-        memory: MemoryId,
+        options: OptionsId,
     },
     WaitableSetPoll {
-        instance: RuntimeComponentInstanceIndex,
-        async_: bool,
-        memory: MemoryId,
+        options: OptionsId,
     },
     WaitableSetDrop {
         instance: RuntimeComponentInstanceIndex,
@@ -358,11 +359,11 @@ pub enum Trampoline {
     },
     StreamRead {
         ty: TypeStreamTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     StreamWrite {
         ty: TypeStreamTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     StreamCancelRead {
         ty: TypeStreamTableIndex,
@@ -383,11 +384,11 @@ pub enum Trampoline {
     },
     FutureRead {
         ty: TypeFutureTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     FutureWrite {
         ty: TypeFutureTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     FutureCancelRead {
         ty: TypeFutureTableIndex,
@@ -405,11 +406,11 @@ pub enum Trampoline {
     },
     ErrorContextNew {
         ty: TypeComponentLocalErrorContextTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     ErrorContextDebugMessage {
         ty: TypeComponentLocalErrorContextTableIndex,
-        options: CanonicalOptions,
+        options: OptionsId,
     },
     ErrorContextDrop {
         ty: TypeComponentLocalErrorContextTableIndex,
@@ -554,6 +555,8 @@ impl ComponentDfg {
             trampolines: Default::default(),
             trampoline_defs: Default::default(),
             trampoline_map: Default::default(),
+            options: Default::default(),
+            options_map: Default::default(),
         };
 
         // Handle all side effects of this component in the order that they're
@@ -585,6 +588,7 @@ impl ComponentDfg {
                 initializers: linearize.initializers,
                 trampolines: linearize.trampolines,
                 num_lowerings: linearize.num_lowerings,
+                options: linearize.options,
 
                 num_runtime_memories: linearize.runtime_memories.len() as u32,
                 num_runtime_tables: linearize.runtime_tables.len() as u32,
@@ -621,13 +625,15 @@ struct LinearizeDfg<'a> {
     initializers: Vec<GlobalInitializer>,
     trampolines: PrimaryMap<TrampolineIndex, ModuleInternedTypeIndex>,
     trampoline_defs: PrimaryMap<TrampolineIndex, info::Trampoline>,
+    options: PrimaryMap<OptionsIndex, info::CanonicalOptions>,
     trampoline_map: HashMap<TrampolineIndex, TrampolineIndex>,
     runtime_memories: HashMap<MemoryId, RuntimeMemoryIndex>,
     runtime_tables: HashMap<TableId, RuntimeTableIndex>,
     runtime_reallocs: HashMap<ReallocId, RuntimeReallocIndex>,
     runtime_callbacks: HashMap<CallbackId, RuntimeCallbackIndex>,
     runtime_post_return: HashMap<PostReturnId, RuntimePostReturnIndex>,
     runtime_instances: HashMap<RuntimeInstance, RuntimeInstanceIndex>,
+    options_map: HashMap<OptionsId, OptionsIndex>,
     num_lowerings: u32,
 }
 
@@ -699,7 +705,7 @@ impl LinearizeDfg<'_> {
         let item = match export {
             Export::LiftedFunction { ty, func, options } => {
                 let func = self.core_def(func);
-                let options = self.options(options);
+                let options = self.options(*options);
                 info::Export::LiftedFunction {
                     ty: *ty,
                     func,
@@ -731,7 +737,16 @@ impl LinearizeDfg<'_> {
         Ok(items.push(item))
     }
 
-    fn options(&mut self, options: &CanonicalOptions) -> info::CanonicalOptions {
+    fn options(&mut self, options: OptionsId) -> OptionsIndex {
+        self.intern_no_init(
+            options,
+            |me| &mut me.options_map,
+            |me, options| me.convert_options(options),
+        )
+    }
+
+    fn convert_options(&mut self, options: OptionsId) -> OptionsIndex {
+        let options = &self.dfg.options[options];
         let data_model = match options.data_model {
             CanonicalOptionsDataModel::Gc {} => info::CanonicalOptionsDataModel::Gc {},
             CanonicalOptionsDataModel::LinearMemory { memory, realloc } => {
@@ -743,15 +758,16 @@ impl LinearizeDfg<'_> {
         };
         let callback = options.callback.map(|mem| self.runtime_callback(mem));
         let post_return = options.post_return.map(|mem| self.runtime_post_return(mem));
-        info::CanonicalOptions {
+        let options = info::CanonicalOptions {
             instance: options.instance,
             string_encoding: options.string_encoding,
             callback,
             post_return,
             async_: options.async_,
             core_type: options.core_type,
             data_model,
-        }
+        };
+        self.options.push(options)
     }
 
     fn runtime_memory(&mut self, mem: MemoryId) -> RuntimeMemoryIndex {
@@ -818,7 +834,7 @@ impl LinearizeDfg<'_> {
                 });
                 info::Trampoline::LowerImport {
                     index,
-                    options: self.options(options),
+                    options: self.options(*options),
                     lower_ty: *lower_ty,
                 }
             }
@@ -844,31 +860,19 @@ impl LinearizeDfg<'_> {
             },
             Trampoline::TaskReturn { results, options } => info::Trampoline::TaskReturn {
                 results: *results,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::TaskCancel { instance } => info::Trampoline::TaskCancel {
                 instance: *instance,
             },
             Trampoline::WaitableSetNew { instance } => info::Trampoline::WaitableSetNew {
                 instance: *instance,
             },
-            Trampoline::WaitableSetWait {
-                instance,
-                async_,
-                memory,
-            } => info::Trampoline::WaitableSetWait {
-                instance: *instance,
-                async_: *async_,
-                memory: self.runtime_memory(*memory),
+            Trampoline::WaitableSetWait { options } => info::Trampoline::WaitableSetWait {
+                options: self.options(*options),
             },
-            Trampoline::WaitableSetPoll {
-                instance,
-                async_,
-                memory,
-            } => info::Trampoline::WaitableSetPoll {
-                instance: *instance,
-                async_: *async_,
-                memory: self.runtime_memory(*memory),
+            Trampoline::WaitableSetPoll { options } => info::Trampoline::WaitableSetPoll {
+                options: self.options(*options),
             },
             Trampoline::WaitableSetDrop { instance } => info::Trampoline::WaitableSetDrop {
                 instance: *instance,
@@ -887,11 +891,11 @@ impl LinearizeDfg<'_> {
             Trampoline::StreamNew { ty } => info::Trampoline::StreamNew { ty: *ty },
             Trampoline::StreamRead { ty, options } => info::Trampoline::StreamRead {
                 ty: *ty,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::StreamWrite { ty, options } => info::Trampoline::StreamWrite {
                 ty: *ty,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::StreamCancelRead { ty, async_ } => info::Trampoline::StreamCancelRead {
                 ty: *ty,
@@ -910,11 +914,11 @@ impl LinearizeDfg<'_> {
             Trampoline::FutureNew { ty } => info::Trampoline::FutureNew { ty: *ty },
             Trampoline::FutureRead { ty, options } => info::Trampoline::FutureRead {
                 ty: *ty,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::FutureWrite { ty, options } => info::Trampoline::FutureWrite {
                 ty: *ty,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::FutureCancelRead { ty, async_ } => info::Trampoline::FutureCancelRead {
                 ty: *ty,
@@ -932,12 +936,12 @@ impl LinearizeDfg<'_> {
             }
             Trampoline::ErrorContextNew { ty, options } => info::Trampoline::ErrorContextNew {
                 ty: *ty,
-                options: self.options(options),
+                options: self.options(*options),
             },
             Trampoline::ErrorContextDebugMessage { ty, options } => {
                 info::Trampoline::ErrorContextDebugMessage {
                     ty: *ty,
-                    options: self.options(options),
+                    options: self.options(*options),
                 }
             }
             Trampoline::ErrorContextDrop { ty } => info::Trampoline::ErrorContextDrop { ty: *ty },
@@ -1034,6 +1038,35 @@ impl LinearizeDfg<'_> {
         generate: impl FnOnce(&mut Self, K) -> T,
         init: impl FnOnce(V, T) -> GlobalInitializer,
     ) -> V
+    where
+        K: Hash + Eq + Copy,
+        V: EntityRef,
+    {
+        self.intern_(key, map, generate, |me, key, val| {
+            me.initializers.push(init(key, val));
+        })
+    }
+
+    fn intern_no_init<K, V, T>(
+        &mut self,
+        key: K,
+        map: impl Fn(&mut Self) -> &mut HashMap<K, V>,
+        generate: impl FnOnce(&mut Self, K) -> T,
+    ) -> V
+    where
+        K: Hash + Eq + Copy,
+        V: EntityRef,
+    {
+        self.intern_(key, map, generate, |_me, _key, _val| {})
+    }
+
+    fn intern_<K, V, T>(
+        &mut self,
+        key: K,
+        map: impl Fn(&mut Self) -> &mut HashMap<K, V>,
+        generate: impl FnOnce(&mut Self, K) -> T,
+        init: impl FnOnce(&mut Self, V, T),
+    ) -> V
     where
         K: Hash + Eq + Copy,
         V: EntityRef,
@@ -1043,7 +1076,7 @@ impl LinearizeDfg<'_> {
         }
         let tmp = generate(self, key);
         let index = V::new(map(self).len());
-        self.initializers.push(init(index, tmp));
+        init(self, index, tmp);
         let prev = map(self).insert(key, index);
         assert!(prev.is_none());
         index