Initial component model and GC support in fused adapters

This lays down the initial infrastructure for support for GC in our fused
adapters for the component model. We keep track of whether each lifted/lowered
function wants args/results as GC values or in linear memory. We additionally
plumb through the core function types of the functions being lifted and lowered
for (eventual) use with GC adapters.

Ultimately, this commit is enough to fuse together lifted and lowered functions
where one or both are using the GC variant of the canonical ABI. Attempting to
actually pass arguments will hit `todo!()`s. The work of implementing those
`todo!()`s is left to future commits.

Author: fitzgen

crates/cranelift/src/compiler/component.rs

@@ -388,6 +388,11 @@ impl<'a> TrampolineCompiler<'a> {
     }
 
     fn translate_task_return_call(&mut self, results: TypeTupleIndex, options: &CanonicalOptions) {
+        let mem_opts = match &options.data_model {
+            CanonicalOptionsDataModel::Gc { core_type: _ } => todo!("CM+GC"),
+            CanonicalOptionsDataModel::LinearMemory(opts) => opts,
+        };
+
         let args = self.builder.func.dfg.block_params(self.block0).to_vec();
         let vmctx = args[0];
 
@@ -398,7 +403,7 @@ impl<'a> TrampolineCompiler<'a> {
             .ins()
             .iconst(ir::types::I32, i64::from(results.as_u32()));
 
-        let memory = self.load_optional_memory(vmctx, options.memory);
+        let memory = self.load_optional_memory(vmctx, mem_opts.memory);
         let string_encoding = self.string_encoding(options.string_encoding);
 
         self.translate_intrinsic_libcall(
@@ -739,16 +744,20 @@ impl<'a> TrampolineCompiler<'a> {
 
         let CanonicalOptions {
             instance,
-            memory,
-            realloc,
             callback,
             post_return,
             string_encoding,
             async_,
+            data_model,
         } = *options;
 
         assert!(callback.is_none());
 
+        let LinearMemoryOptions { memory, realloc } = match data_model {
+            CanonicalOptionsDataModel::Gc { core_type: _ } => todo!("CM+GC"),
+            CanonicalOptionsDataModel::LinearMemory(opts) => opts,
+        };
+
         // vmctx: *mut VMComponentContext
         host_sig.params.push(ir::AbiParam::new(pointer_type));
         callee_args.push(vmctx);
@@ -1298,10 +1307,15 @@ impl<'a> TrampolineCompiler<'a> {
         let mut callee_args = vec![vmctx];
 
         if let Some(options) = options {
+            let mem_opts = match options.data_model {
+                CanonicalOptionsDataModel::Gc { core_type: _ } => todo!("CM+GC"),
+                CanonicalOptionsDataModel::LinearMemory(opts) => opts,
+            };
+
             // memory: *mut VMMemoryDefinition
-            callee_args.push(self.load_memory(vmctx, options.memory.unwrap()));
+            callee_args.push(self.load_memory(vmctx, mem_opts.memory.unwrap()));
             // realloc: *mut VMFuncRef
-            callee_args.push(self.load_realloc(vmctx, options.realloc));
+            callee_args.push(self.load_realloc(vmctx, mem_opts.realloc));
             // string_encoding: StringEncoding
             callee_args.push(self.string_encoding(options.string_encoding));
             // async: bool
@@ -1328,12 +1342,17 @@ impl<'a> TrampolineCompiler<'a> {
         get_libcall: GetLibcallFn,
         info: &CanonicalAbiInfo,
     ) {
+        let mem_opts = match &options.data_model {
+            CanonicalOptionsDataModel::Gc { core_type: _ } => todo!("CM+GC"),
+            CanonicalOptionsDataModel::LinearMemory(opts) => opts,
+        };
+
         let args = self.builder.func.dfg.block_params(self.block0).to_vec();
         let vmctx = args[0];
         let mut callee_args = vec![
             vmctx,
-            self.load_memory(vmctx, options.memory.unwrap()),
-            self.load_realloc(vmctx, options.realloc),
+            self.load_memory(vmctx, mem_opts.memory.unwrap()),
+            self.load_realloc(vmctx, mem_opts.realloc),
             self.builder
                 .ins()
                 .iconst(ir::types::I8, if options.async_ { 1 } else { 0 }),
@@ -1368,12 +1387,17 @@ impl<'a> TrampolineCompiler<'a> {
         get_libcall: GetLibcallFn,
         sentinel: TrapSentinel,
     ) {
+        let mem_opts = match &options.data_model {
+            CanonicalOptionsDataModel::Gc { core_type: _ } => todo!("CM+GC"),
+            CanonicalOptionsDataModel::LinearMemory(opts) => opts,
+        };
+
         let args = self.builder.func.dfg.block_params(self.block0).to_vec();
         let vmctx = args[0];
         let mut callee_args = vec![
             vmctx,
-            self.load_memory(vmctx, options.memory.unwrap()),
-            self.load_realloc(vmctx, options.realloc),
+            self.load_memory(vmctx, mem_opts.memory.unwrap()),
+            self.load_realloc(vmctx, mem_opts.realloc),
             self.string_encoding(options.string_encoding),
             self.builder
                 .ins()

crates/environ/src/component/dfg.rs

@@ -32,6 +32,7 @@ use crate::prelude::*;
 use crate::{EntityIndex, EntityRef, ModuleInternedTypeIndex, PrimaryMap, WasmValType};
 use anyhow::Result;
 use indexmap::IndexMap;
+use info::LinearMemoryOptions;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::ops::Index;
@@ -194,6 +195,7 @@ pub enum Export {
     LiftedFunction {
         ty: TypeFuncIndex,
         func: CoreDef,
+        func_ty: ModuleInternedTypeIndex,
         options: CanonicalOptions,
     },
     ModuleStatic {
@@ -414,17 +416,29 @@ pub struct StreamInfo {
     pub payload_type: InterfaceType,
 }
 
+/// Same as `info::CanonicalOptionsDataModel`.
+#[derive(Clone, Hash, Eq, PartialEq)]
+#[expect(missing_docs, reason = "self-describing fields")]
+pub enum CanonicalOptionsDataModel {
+    Gc {
+        core_type: ModuleInternedTypeIndex,
+    },
+    LinearMemory {
+        memory: Option<MemoryId>,
+        realloc: Option<ReallocId>,
+    },
+}
+
 /// Same as `info::CanonicalOptions`
 #[derive(Clone, Hash, Eq, PartialEq)]
 #[expect(missing_docs, reason = "self-describing fields")]
 pub struct CanonicalOptions {
     pub instance: RuntimeComponentInstanceIndex,
     pub string_encoding: StringEncoding,
-    pub memory: Option<MemoryId>,
-    pub realloc: Option<ReallocId>,
     pub callback: Option<CallbackId>,
     pub post_return: Option<PostReturnId>,
     pub async_: bool,
+    pub data_model: CanonicalOptionsDataModel,
 }
 
 /// Same as `info::Resource`
@@ -651,12 +665,18 @@ impl LinearizeDfg<'_> {
         wasmparser_types: wasmparser::types::TypesRef<'_>,
     ) -> Result<ExportIndex> {
         let item = match export {
-            Export::LiftedFunction { ty, func, options } => {
+            Export::LiftedFunction {
+                ty,
+                func,
+                func_ty,
+                options,
+            } => {
                 let func = self.core_def(func);
                 let options = self.options(options);
                 info::Export::LiftedFunction {
                     ty: *ty,
                     func,
+                    func_ty: *func_ty,
                     options,
                 }
             }
@@ -686,18 +706,26 @@ impl LinearizeDfg<'_> {
     }
 
     fn options(&mut self, options: &CanonicalOptions) -> info::CanonicalOptions {
-        let memory = options.memory.map(|mem| self.runtime_memory(mem));
-        let realloc = options.realloc.map(|mem| self.runtime_realloc(mem));
+        let data_model = match options.data_model {
+            CanonicalOptionsDataModel::Gc { core_type } => {
+                info::CanonicalOptionsDataModel::Gc { core_type }
+            }
+            CanonicalOptionsDataModel::LinearMemory { memory, realloc } => {
+                info::CanonicalOptionsDataModel::LinearMemory(LinearMemoryOptions {
+                    memory: memory.map(|mem| self.runtime_memory(mem)),
+                    realloc: realloc.map(|mem| self.runtime_realloc(mem)),
+                })
+            }
+        };
         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 {
             instance: options.instance,
             string_encoding: options.string_encoding,
-            memory,
-            realloc,
             callback,
             post_return,
             async_: options.async_,
+            data_model,
         }
     }
 

crates/environ/src/component/info.rs

@@ -450,6 +450,8 @@ pub enum Export {
         ty: TypeFuncIndex,
         /// Which core WebAssembly export is being lifted.
         func: CoreDef,
+        /// The core function's type.
+        func_ty: ModuleInternedTypeIndex,
         /// Any options, if present, associated with this lifting.
         options: CanonicalOptions,
     },
@@ -480,6 +482,28 @@ pub enum Export {
     Type(TypeDef),
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+/// Data is stored in a linear memory.
+pub struct LinearMemoryOptions {
+    /// The memory used by these options, if specified.
+    pub memory: Option<RuntimeMemoryIndex>,
+    /// The realloc function used by these options, if specified.
+    pub realloc: Option<RuntimeReallocIndex>,
+}
+
+/// The data model for objects that are not unboxed in locals.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum CanonicalOptionsDataModel {
+    /// Data is stored in GC objects.
+    Gc {
+        /// The core function type that is being lifted from / lowered to.
+        core_type: ModuleInternedTypeIndex,
+    },
+
+    /// Data is stored in a linear memory.
+    LinearMemory(LinearMemoryOptions),
+}
+
 /// Canonical ABI options associated with a lifted or lowered function.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CanonicalOptions {
@@ -489,12 +513,6 @@ pub struct CanonicalOptions {
     /// The encoding used for strings.
     pub string_encoding: StringEncoding,
 
-    /// The memory used by these options, if specified.
-    pub memory: Option<RuntimeMemoryIndex>,
-
-    /// The realloc function used by these options, if specified.
-    pub realloc: Option<RuntimeReallocIndex>,
-
     /// The async callback function used by these options, if specified.
     pub callback: Option<RuntimeCallbackIndex>,
 
@@ -503,6 +521,10 @@ pub struct CanonicalOptions {
 
     /// Whether to use the async ABI for lifting or lowering.
     pub async_: bool,
+
+    /// The data model (GC objects or linear memory) used with these canonical
+    /// options.
+    pub data_model: CanonicalOptionsDataModel,
 }
 
 /// Possible encodings of strings within the component model.