Struct SerializableModule

pub struct SerializableModule {
    pub compilation: SerializableCompilation,
    pub compile_info: CompileModuleInfo,
    pub data_initializers: Box<[OwnedDataInitializer]>,
    pub cpu_features: u64,
}

Serializable struct that is able to serialize from and to a ArtifactInfo.

Fields

compilation: SerializableCompilation

The main serializable compilation object

compile_info: CompileModuleInfo

Compilation informations

data_initializers: Box<[OwnedDataInitializer]>

Datas initializers

cpu_features: u64

CPU Feature flags for this compilation

Implementations

impl SerializableModule

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_unchecked( 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 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)

Unlike Self::deserialize, this function will validate the data.

Safety

Unsafe because it loads executable code into memory. The loaded bytes must be trusted.

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

Safety

This method is unsafe. Please check SerializableModule::deserialize for more details.

pub fn archive_from_slice_checked( metadata_slice: &[u8], ) -> Result<&ArchivedSerializableModule, DeserializeError>

Deserialize an archived module.

In contrast to Self::deserialize, this method performs validation and is not unsafe.

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

Deserialize a compilation module from an archive

pub fn create_module_info(&self) -> ModuleInfo

Create a ModuleInfo for instantiation

pub fn module_info(&self) -> &ModuleInfo

Returns the ModuleInfo for instantiation

pub fn features(&self) -> &Features

Returns the features for this Artifact

pub fn cpu_features(&self) -> EnumSet<CpuFeature>

Returns the CPU features for this Artifact

pub fn data_initializers(&self) -> &[OwnedDataInitializer]

Returns data initializers to pass to VMInstance::initialize

pub fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle>

Returns the memory styles associated with this Artifact.

pub fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle>

Returns the table plans associated with this Artifact.

Trait Implementations

impl Archive for SerializableModule

where SerializableCompilation: Archive, CompileModuleInfo: Archive, Box<[OwnedDataInitializer]>: Archive, u64: Archive,

type Archived = ArchivedSerializableModule

The archived representation of this type.

type Resolver = SerializableModuleResolver

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<__D: Fallible + ?Sized> Deserialize<SerializableModule, __D> for Archived<SerializableModule>

where SerializableCompilation: Archive, Archived<SerializableCompilation>: Deserialize<SerializableCompilation, __D>, CompileModuleInfo: Archive, Archived<CompileModuleInfo>: Deserialize<CompileModuleInfo, __D>, Box<[OwnedDataInitializer]>: Archive, Archived<Box<[OwnedDataInitializer]>>: Deserialize<Box<[OwnedDataInitializer]>, __D>, u64: Archive, Archived<u64>: Deserialize<u64, __D>,

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

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for SerializableModule

where SerializableCompilation: Serialize<__S>, CompileModuleInfo: Serialize<__S>, Box<[OwnedDataInitializer]>: 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.