Remove core wasm name guess in adapter GC

This commit removes the need for the GC pass on the adapter module to
guess what core wasm export names are needed for WIT. Previously it was
assumed that certain exports would have exact core wasm names but that's
going to change soon so this refactoring is empowering these future changes.

The GC pass for adapters is restructured to run validation over the
non-GC'd adapter first. This validation pass will identify WIT export
functions and such and then this information is used to determine the
set of live exports. These live exports are then used to perform a GC
pass, and then afterwards the validation pass is run a second time to
recalculate information with possibly-removed imports.

Author: alexcrichton

crates/wit-component/src/encoding/world.rs

@@ -6,9 +6,8 @@ use anyhow::{Context, Result};
 use indexmap::{IndexMap, IndexSet};
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
-use wasmparser::FuncType;
 use wit_parser::{
-    abi::{AbiVariant, WasmSignature, WasmType},
+    abi::{AbiVariant, WasmSignature},
     Function, InterfaceId, LiveTypes, Resolve, TypeDefKind, TypeId, TypeOwner, WorldId, WorldItem,
     WorldKey,
 };
@@ -130,12 +129,51 @@ impl<'a> ComponentWorld<'a> {
             let wasm = if library_info.is_some() {
                 Cow::Borrowed(wasm as &[u8])
             } else {
-                let required = self.required_adapter_exports(
+                // Without `library_info` this means that this is an adapter.
+                // The goal of the adapter is to provide a suite of symbols that
+                // can be imported, but not all symbols may be imported. Here
+                // the module is trimmed down to only what's needed by the
+                // original main module.
+                //
+                // The main module requires `required_by_import` above, but
+                // adapters may themselves also export WIT items. To handle this
+                // the sequence of operations here are:
+                //
+                // 1. First the adapter is validated as-is. This ensures that
+                //    everything looks good before GC.
+                // 2. The metadata from step (1) is used to determine the set of
+                //    WIT-level exports that are needed. This includes things
+                //    like realloc functions and such.
+                // 3. The set of WIT-level functions from (2) is unioned with
+                //    `required_by_import` to create the set of required exports
+                //    of the adapter.
+                // 4. This set of exports is used to delete some exports of the
+                //    adapter and then perform a GC pass.
+                //
+                // Finally at the end of all of this the
+                // `validate_adapter_module` method is called for a second time
+                // on the minimized adapter. This is done because deleting
+                // imports may have deleted some imports which means that the
+                // final component may not need to import as many interfaces.
+                let info = validate_adapter_module(
+                    &wasm,
                     resolve,
                     world,
-                    required_exports,
                     &required_by_import,
-                );
+                    required_exports,
+                    library_info.as_ref(),
+                    adapters,
+                )
+                .with_context(|| {
+                    format!("failed to validate the imports of the adapter module `{name}`")
+                })?;
+                let mut required = IndexSet::new();
+                for (name, _ty) in required_by_import.iter() {
+                    required.insert(name.to_string());
+                }
+                for (name, _export) in info.exports.iter() {
+                    required.insert(name.to_string());
+                }
 
                 Cow::Owned(
                     crate::gc::run(
@@ -174,64 +212,6 @@ impl<'a> ComponentWorld<'a> {
         Ok(())
     }
 
-    /// Returns the set of functions required to be exported from an adapter,
-    /// either because they're exported from the adapter's world or because
-    /// they're required as an import to the main module.
-    fn required_adapter_exports<'r>(
-        &self,
-        resolve: &'r Resolve,
-        world: WorldId,
-        required_exports: &IndexSet<WorldKey>,
-        required_by_import: &IndexMap<String, FuncType>,
-    ) -> IndexMap<String, (FuncType, Option<&'r Function>)> {
-        use wasmparser::ValType;
-
-        let mut required = IndexMap::new();
-        for (name, ty) in required_by_import {
-            required.insert(name.to_string(), (ty.clone(), None));
-        }
-        let mut add_func = |func: &'r Function, name: Option<&str>| {
-            let name = func.core_export_name(name);
-            let ty = resolve.wasm_signature(AbiVariant::GuestExport, func);
-            let prev = required.insert(
-                name.into_owned(),
-                (
-                    wasmparser::FuncType::new(
-                        ty.params.iter().map(to_valty),
-                        ty.results.iter().map(to_valty),
-                    ),
-                    Some(func),
-                ),
-            );
-            assert!(prev.is_none());
-        };
-        for name in required_exports {
-            match &resolve.worlds[world].exports[name] {
-                WorldItem::Function(func) => add_func(func, None),
-                WorldItem::Interface { id, .. } => {
-                    let name = resolve.name_world_key(name);
-                    for (_, func) in resolve.interfaces[*id].functions.iter() {
-                        add_func(func, Some(&name));
-                    }
-                }
-                WorldItem::Type(_) => {}
-            }
-        }
-        return required;
-
-        fn to_valty(ty: &WasmType) -> ValType {
-            match ty {
-                WasmType::I32 => ValType::I32,
-                WasmType::I64 => ValType::I64,
-                WasmType::F32 => ValType::F32,
-                WasmType::F64 => ValType::F64,
-                WasmType::Pointer => ValType::I32,
-                WasmType::PointerOrI64 => ValType::I64,
-                WasmType::Length => ValType::I32,
-            }
-        }
-    }
-
     /// Fills out the `import_map` field of `self` by determining the live
     /// functions from all imports. This additionally classifies imported
     /// functions into direct or indirect lowerings for managing shims.

crates/wit-component/src/gc.rs

@@ -19,9 +19,9 @@ const PAGE_SIZE: i32 = 64 * 1024;
 ///
 /// This internally performs a "gc" pass after removing exports to ensure that
 /// the resulting module imports the minimal set of functions necessary.
-pub fn run<T>(
+pub fn run(
     wasm: &[u8],
-    required: &IndexMap<String, T>,
+    required: &IndexSet<String>,
     main_module_realloc: Option<&str>,
 ) -> Result<Vec<u8>> {
     assert!(!required.is_empty());
@@ -31,21 +31,14 @@ pub fn run<T>(
 
     // Make sure that all required names are present in the module, and then
     // remove all names that are not required.
-    for (name, _ty) in required {
+    for name in required {
         if !module.exports.contains_key(name.as_str()) {
             bail!("adapter module does not have export `{name}`")
         }
     }
     let mut not_required = IndexSet::new();
     for name in module.exports.keys().copied() {
-        // If we need `name` then we also need cabi_post_`name`:
-        let name = if let Some(suffix) = name.strip_prefix("cabi_post_") {
-            suffix
-        } else {
-            name
-        };
-
-        if !required.contains_key(name) && !always_keep(name) {
+        if !required.contains(name) {
             not_required.insert(name);
         }
     }
@@ -57,15 +50,6 @@ pub fn run<T>(
     module.encode(main_module_realloc)
 }
 
-fn always_keep(name: &str) -> bool {
-    match name {
-        // Explicitly keep `cabi_realloc` if it's there in case an interface
-        // needs it for a lowering.
-        "cabi_realloc" | "cabi_import_realloc" | "cabi_export_realloc" => true,
-        _ => false,
-    }
-}
-
 /// This function generates a Wasm function body which implements `cabi_realloc` in terms of `memory.grow`.  It
 /// only accepts new, page-sized allocations.
 fn realloc_via_memory_grow() -> wasm_encoder::Function {