Struct wasmer_types::compilation::symbols::ModuleMetadata

pub struct ModuleMetadata {
    pub compile_info: CompileModuleInfo,
    pub prefix: String,
    pub data_initializers: Box<[OwnedDataInitializer]>,
    pub function_body_lengths: PrimaryMap<LocalFunctionIndex, u64>,
    pub cpu_features: u64,
}

Serializable struct that represents the compiled metadata.

Fields

compile_info: CompileModuleInfo

Compile info

prefix: String

Prefix for function etc symbols

data_initializers: Box<[OwnedDataInitializer]>

Data initializers

function_body_lengths: PrimaryMap<LocalFunctionIndex, u64>

The function body lengths (used to find function by address)

cpu_features: u64

CPU features used (See [CpuFeature])

Implementations

impl ModuleMetadata

pub fn split(
    &mut self
) -> (&mut CompileModuleInfo, ModuleMetadataSymbolRegistry)

Get mutable ref to compile info and a copy of the registry

pub fn get_symbol_registry(&self) -> ModuleMetadataSymbolRegistry

Returns symbol registry.

pub fn serialize(&self) -> Result<Vec<u8>, SerializeError>

Serialize a Module into bytes The bytes will have the following format: RKYV serialization (any length) + POS (8 bytes)

pub unsafe fn deserialize(
    metadata_slice: &[u8]
) -> Result<Self, DeserializeError>

Deserialize a Module from a slice. The slice must have the following format: RKYV serialization (any length) + POS (8 bytes)

Safety

This method is unsafe since it deserializes data directly from memory. Right now we are not doing any extra work for validation, but rkyv has an option to do bytecheck on the serialized data before serializing (via rkyv::check_archived_value).

pub fn deserialize_from_archive(
    archived: &ArchivedModuleMetadata
) -> Result<Self, DeserializeError>

Deserialize a compilation module from an archive

Trait Implementations

impl Archive for ModuleMetadata where
    CompileModuleInfo: Archive,
    String: Archive,
    Box<[OwnedDataInitializer]>: Archive,
    PrimaryMap<LocalFunctionIndex, u64>: Archive,
    u64: Archive, 

type Archived = ArchivedModuleMetadata

The archived representation of this type.

type Resolver = ModuleMetadataResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve(
    &self,
    pos: usize,
    resolver: Self::Resolver,
    out: *mut Self::Archived
)

Creates the archived version of this value at the given position and writes it to the given output.

impl Debug for ModuleMetadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<ModuleMetadata, __D> for Archived<ModuleMetadata> where
    CompileModuleInfo: Archive,
    Archived<CompileModuleInfo>: Deserialize<CompileModuleInfo, __D>,
    String: Archive,
    Archived<String>: Deserialize<String, __D>,
    Box<[OwnedDataInitializer]>: Archive,
    Archived<Box<[OwnedDataInitializer]>>: Deserialize<Box<[OwnedDataInitializer]>, __D>,
    PrimaryMap<LocalFunctionIndex, u64>: Archive,
    Archived<PrimaryMap<LocalFunctionIndex, u64>>: Deserialize<PrimaryMap<LocalFunctionIndex, u64>, __D>,
    u64: Archive,
    Archived<u64>: Deserialize<u64, __D>, 

fn deserialize(
    &self,
    deserializer: &mut __D
) -> Result<ModuleMetadata, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for ModuleMetadata where
    CompileModuleInfo: Serialize<__S>,
    String: Serialize<__S>,
    Box<[OwnedDataInitializer]>: Serialize<__S>,
    PrimaryMap<LocalFunctionIndex, u64>: Serialize<__S>,
    u64: Serialize<__S>, 

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.