wasmtime_environ/component/artifacts.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
//! Definitions of compilation artifacts of the component compilation process
//! which are serialized with `bincode` into output ELF files.
use crate::{
component::{Component, ComponentTypes, TrampolineIndex, TypeComponentIndex},
CompiledModuleInfo, FunctionLoc, PrimaryMap, StaticModuleIndex,
};
use serde_derive::{Deserialize, Serialize};
/// Serializable state that's stored in a compilation artifact.
#[derive(Serialize, Deserialize)]
pub struct ComponentArtifacts {
/// The type of this component.
pub ty: TypeComponentIndex,
/// Information all kept available at runtime as-is.
pub info: CompiledComponentInfo,
/// Type information for this component and all contained modules.
pub types: ComponentTypes,
/// Serialized metadata about all included core wasm modules.
pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
}
/// Runtime state that a component retains to support its operation.
#[derive(Serialize, Deserialize)]
pub struct CompiledComponentInfo {
/// Type information calculated during translation about this component.
pub component: Component,
/// Where lowered function trampolines are located within the `text`
/// section of `code_memory`.
///
/// These are the
///
/// 1. Wasm-call,
/// 2. array-call
///
/// function pointers that end up in a `VMFuncRef` for each
/// lowering.
pub trampolines: PrimaryMap<TrampolineIndex, AllCallFunc<FunctionLoc>>,
/// The location of the wasm-to-array trampoline for the `resource.drop`
/// intrinsic.
pub resource_drop_wasm_to_array_trampoline: Option<FunctionLoc>,
}
/// A triple of related functions/trampolines variants with differing calling
/// conventions: `{wasm,array}_call`.
///
/// Generic so we can use this with either the `Box<dyn Any + Send>`s that
/// implementations of the compiler trait return or with `FunctionLoc`s inside
/// an object file, for example.
#[derive(Clone, Copy, Default, Serialize, Deserialize)]
pub struct AllCallFunc<T> {
/// The function exposing the Wasm calling convention.
pub wasm_call: T,
/// The function exposing the array calling convention.
pub array_call: T,
}
impl<T> AllCallFunc<T> {
/// Map an `AllCallFunc<T>` into an `AllCallFunc<U>`.
pub fn map<U>(self, mut f: impl FnMut(T) -> U) -> AllCallFunc<U> {
AllCallFunc {
wasm_call: f(self.wasm_call),
array_call: f(self.array_call),
}
}
}