Handle OOM in wasmtime_environ::types::WasmFuncType (#12670)

* Handle OOM in `wasmtime_environ::types::WasmFuncType`

It should also not `#[derive(Clone)]` anymore, just `TryClone`, which
propagates out to a bunch of other types as well.

And while we are here:

* Rename its "returns" to "results" to match Wasmtime's public API and also the
  Wasm text format.
* Store both its params and results in a single allocation.
* Shrink its size on 64-bit architectures by storing its param- and
  result-GC-type counts as `u32`s rather than `usize`s.

* fix clippy

* fix winch unit tests

Author: fitzgen

crates/cranelift/src/compiler.rs

@@ -465,7 +465,7 @@ impl wasmtime_environ::Compiler for Compiler {
 
         // Return results from the array as native return values.
         let results =
-            self.load_values_from_array(wasm_func_ty.returns(), &mut builder, args_base, args_len);
+            self.load_values_from_array(wasm_func_ty.results(), &mut builder, args_base, args_len);
         builder.ins().return_(&results);
         builder.finalize();
 
@@ -1068,7 +1068,7 @@ impl Compiler {
 
         // Compute the size of the values vector.
         let value_size = mem::size_of::<u128>();
-        let values_vec_len = cmp::max(ty.params().len(), ty.returns().len());
+        let values_vec_len = cmp::max(ty.params().len(), ty.results().len());
         let values_vec_byte_size = u32::try_from(value_size * values_vec_len).unwrap();
         let values_vec_len = u32::try_from(values_vec_len).unwrap();
 
@@ -1419,7 +1419,7 @@ impl Compiler {
         builder.switch_to_block(normal_return);
         self.store_values_to_array(
             &mut builder,
-            callee_sig.returns(),
+            callee_sig.results(),
             &normal_return_values,
             values_vec_ptr,
             values_vec_len,

crates/cranelift/src/compiler/component.rs

@@ -10,8 +10,8 @@ use cranelift_codegen::isa::{CallConv, TargetIsa};
 use cranelift_frontend::FunctionBuilder;
 use wasmtime_environ::error::{Result, bail};
 use wasmtime_environ::{
-    Abi, BuiltinFunctionIndex, CompiledFunctionBody, EntityRef, FuncKey, HostCall, PtrSize,
-    TrapSentinel, Tunables, WasmFuncType, WasmValType, component::*,
+    Abi, BuiltinFunctionIndex, CompiledFunctionBody, EntityRef, FuncKey, HostCall, PanicOnOom as _,
+    PtrSize, TrapSentinel, Tunables, WasmFuncType, WasmValType, component::*,
     fact::PREPARE_CALL_FIXED_PARAMS,
 };
 
@@ -177,7 +177,7 @@ impl<'a> TrampolineCompiler<'a> {
             }
             Trampoline::ResourceRep { instance, ty } => {
                 // Currently this only supports resources represented by `i32`
-                assert_eq!(self.signature.returns()[0], WasmValType::I32);
+                assert_eq!(self.signature.results()[0], WasmValType::I32);
                 self.translate_libcall(
                     host::resource_rep32,
                     TrapSentinel::NegativeOne,
@@ -639,10 +639,7 @@ impl<'a> TrampolineCompiler<'a> {
             Trampoline::SyncStartCall { callback } => {
                 let pointer_type = self.isa.pointer_type();
                 let (values_vec_ptr, len) = self.compiler.allocate_stack_array_and_spill_args(
-                    &WasmFuncType::new(
-                        Box::new([]),
-                        self.signature.returns().iter().copied().collect(),
-                    ),
+                    &WasmFuncType::new([], self.signature.results().iter().copied()).panic_on_oom(),
                     &mut self.builder,
                     &[],
                 );
@@ -972,10 +969,8 @@ impl<'a> TrampolineCompiler<'a> {
             // A mixture of the above two.
             WasmArgs::InRegistersUpTo(n) => {
                 let (values_vec_ptr, len) = self.compiler.allocate_stack_array_and_spill_args(
-                    &WasmFuncType::new(
-                        self.signature.params().iter().skip(n).copied().collect(),
-                        Box::new([]),
-                    ),
+                    &WasmFuncType::new(self.signature.params().iter().skip(n).copied(), [])
+                        .panic_on_oom(),
                     &mut self.builder,
                     &wasm_params[n..],
                 );
@@ -1026,7 +1021,7 @@ impl<'a> TrampolineCompiler<'a> {
         // accounts for the ABI of this function when storing results.
         let result = self.builder.func.dfg.inst_results(call).get(0).copied();
         let result_ty = result.map(|v| self.builder.func.dfg.value_type(v));
-        let expected = self.signature.returns();
+        let expected = self.signature.results();
         match host_result.into() {
             HostResult::Sentinel(TrapSentinel::NegativeOne) => {
                 assert_eq!(expected.len(), 1);
@@ -1054,7 +1049,7 @@ impl<'a> TrampolineCompiler<'a> {
                 let len = len.or(val_raw_len).unwrap();
                 self.raise_if_host_trapped(result.unwrap());
                 let results = self.compiler.load_values_from_array(
-                    self.signature.returns(),
+                    self.signature.results(),
                     &mut self.builder,
                     ptr,
                     len,
@@ -1671,9 +1666,10 @@ impl ComponentCompiler for Compiler {
         symbol: &str,
     ) -> Result<CompiledFunctionBody> {
         let wasm_func_ty = WasmFuncType::new(
-            intrinsic.core_params().into(),
-            intrinsic.core_results().into(),
-        );
+            intrinsic.core_params().iter().copied(),
+            intrinsic.core_results().iter().copied(),
+        )
+        .panic_on_oom();
 
         match abi {
             // Fall through to the trampoline compiler.

crates/cranelift/src/func_environ.rs

@@ -2594,7 +2594,7 @@ impl FuncEnvironment<'_> {
 
     pub fn sig_ref_result_needs_stack_map(&self, sig_ref: ir::SigRef, index: usize) -> bool {
         let wasm_func_ty = self.sig_ref_to_ty[sig_ref].as_ref().unwrap();
-        wasm_func_ty.returns()[index].is_vmgcref_type_and_not_i31()
+        wasm_func_ty.results()[index].is_vmgcref_type_and_not_i31()
     }
 
     pub fn translate_table_grow(
@@ -3999,7 +3999,7 @@ impl FuncEnvironment<'_> {
         let idx = self.module.types[index].unwrap_module_type_index();
         self.types[self.types[idx].unwrap_cont().unwrap_module_type_index()]
             .unwrap_func()
-            .returns()
+            .results()
     }
 
     pub fn tag_params(&self, tag_index: TagIndex) -> &[WasmValType] {
@@ -4013,7 +4013,7 @@ impl FuncEnvironment<'_> {
         let idx = self.module.tags[tag_index].signature;
         self.types[idx.unwrap_module_type_index()]
             .unwrap_func()
-            .returns()
+            .results()
     }
 
     pub fn use_blendv_for_relaxed_laneselect(&self, ty: Type) -> bool {

crates/cranelift/src/lib.rs

@@ -203,7 +203,7 @@ fn wasm_call_signature(
     let mut sig = blank_sig(isa, call_conv);
     let cvt = |ty: &WasmValType| ir::AbiParam::new(value_type(isa, *ty));
     sig.params.extend(wasm_func_ty.params().iter().map(&cvt));
-    sig.returns.extend(wasm_func_ty.returns().iter().map(&cvt));
+    sig.returns.extend(wasm_func_ty.results().iter().map(&cvt));
     sig
 }
 

crates/environ/src/collections.rs

@@ -14,7 +14,10 @@ pub use index_map::IndexMap;
 pub use primary_map::PrimaryMap;
 pub use secondary_map::SecondaryMap;
 pub use wasmtime_core::{
-    alloc::{String, TryClone, TryCollect, TryExtend, TryFromIterator, TryNew, Vec, try_new},
+    alloc::{
+        String, TryClone, TryCollect, TryCow, TryExtend, TryFromIterator, TryNew, TryToOwned, Vec,
+        try_new,
+    },
     vec,
 };
 

crates/environ/src/compile/module_types.rs

@@ -1,16 +1,16 @@
 use crate::{
     EngineOrModuleTypeIndex, EntityRef, ModuleInternedRecGroupIndex, ModuleInternedTypeIndex,
-    ModuleTypes, TypeConvert, TypeIndex, WasmArrayType, WasmCompositeInnerType, WasmCompositeType,
-    WasmExnType, WasmFieldType, WasmFuncType, WasmHeapType, WasmResult, WasmStorageType,
-    WasmStructType, WasmSubType, wasm_unsupported,
+    ModuleTypes, PanicOnOom as _, TypeConvert, TypeIndex, WasmArrayType, WasmCompositeInnerType,
+    WasmCompositeType, WasmExnType, WasmFieldType, WasmFuncType, WasmHeapType, WasmResult,
+    WasmStorageType, WasmStructType, WasmSubType,
+    collections::{TryClone as _, TryCow},
+    wasm_unsupported,
 };
 use std::{
-    borrow::Cow,
     collections::{HashMap, hash_map::Entry},
     ops::Index,
 };
 use wasmparser::{UnpackedIndex, Validator, ValidatorId};
-use wasmtime_core::alloc::PanicOnOom as _;
 
 /// A type marking the start of a recursion group's definition.
 ///
@@ -166,19 +166,20 @@ impl ModuleTypesBuilder {
                 // type. We can reuse the definition and its index, but still
                 // need to intern the type into our `trampoline_types` map so we
                 // can reuse it in the future.
-                Cow::Borrowed(f) => {
-                    self.trampoline_types.insert(f.clone(), for_func_ty);
+                TryCow::Borrowed(f) => {
+                    self.trampoline_types
+                        .insert(f.try_clone().panic_on_oom(), for_func_ty);
                     for_func_ty
                 }
                 // The trampoline type is different from the original function
                 // type. Define the trampoline type and then intern it in
                 // `trampoline_types` so we can reuse it in the future.
-                Cow::Owned(f) => {
+                TryCow::Owned(f) => {
                     let idx = self.types.push(WasmSubType {
                         is_final: true,
                         supertype: None,
                         composite_type: WasmCompositeType {
-                            inner: WasmCompositeInnerType::Func(f.clone()),
+                            inner: WasmCompositeInnerType::Func(f.try_clone().panic_on_oom()),
                             shared: sub_ty.composite_type.shared,
                         },
                     });

crates/environ/src/component/types_builder.rs

@@ -173,7 +173,7 @@ impl ComponentTypesBuilder {
             .find(|(_, ty)| {
                 ty.as_func().map_or(false, |sig| {
                     sig.params().len() == 1
-                        && sig.returns().len() == 0
+                        && sig.results().len() == 0
                         && sig.params()[0] == WasmValType::I32
                 })
             })

crates/environ/src/fact/signature.rs

@@ -33,7 +33,7 @@ impl ComponentTypesBuilder {
             .unwrap_func();
         Signature {
             params: f.params().iter().map(|ty| self.val_type(ty)).collect(),
-            results: f.returns().iter().map(|ty| self.val_type(ty)).collect(),
+            results: f.results().iter().map(|ty| self.val_type(ty)).collect(),
         }
     }