wasmi/src/types.rs

195 lines
4.7 KiB
Rust
Raw Normal View History

2018-01-24 11:14:24 +00:00
use std::borrow::Cow;
2018-01-22 13:34:32 +00:00
use parity_wasm::elements::{
FunctionType, ValueType as EValueType, GlobalType, TableType, MemoryType};
2018-01-18 12:54:31 +00:00
/// Signature of a [function].
2018-01-23 16:38:49 +00:00
///
/// Signature of a function consists of zero or more parameter [types][type] and zero or one return [type].
///
/// Two signatures are considered equal if they have equal list of parameters and equal return types.
///
/// [type]: enum.ValueType.html
/// [function]: struct.FuncInstance.html
2018-01-23 16:38:49 +00:00
#[derive(Debug, Clone, PartialEq, Eq)]
2018-01-18 12:54:31 +00:00
pub struct Signature {
2018-01-24 11:14:24 +00:00
params: Cow<'static, [ValueType]>,
2018-01-18 13:39:14 +00:00
return_type: Option<ValueType>,
2018-01-18 12:54:31 +00:00
}
impl Signature {
2018-02-01 16:46:33 +00:00
/// Creates new signature with givens
/// parameter types and optional return type.
///
/// # Examples
///
/// ```rust
/// use wasmi::{Signature, ValueType};
///
/// // s1: (i32) -> ()
/// let s1 = Signature::new(&[ValueType::I32][..], None);
///
/// // s2: () -> i32
/// let s2 = Signature::new(&[][..], Some(ValueType::I32));
///
/// // s3: (I64) -> ()
/// let dynamic_params = vec![ValueType::I64];
/// let s3 = Signature::new(dynamic_params, None);
/// ```
2018-01-24 11:14:24 +00:00
pub fn new<C: Into<Cow<'static, [ValueType]>>>(
params: C,
return_type: Option<ValueType>
) -> Signature {
2018-01-18 12:54:31 +00:00
Signature {
2018-01-24 11:14:24 +00:00
params: params.into(),
2018-01-18 13:39:14 +00:00
return_type: return_type,
2018-01-18 12:54:31 +00:00
}
}
2018-02-01 16:46:33 +00:00
/// Returns parameter types of this signature.
2018-01-18 12:54:31 +00:00
pub fn params(&self) -> &[ValueType] {
2018-01-24 11:14:24 +00:00
&self.params.as_ref()
2018-01-18 12:54:31 +00:00
}
2018-02-01 16:46:33 +00:00
/// Returns return type of this signature.
2018-01-18 12:54:31 +00:00
pub fn return_type(&self) -> Option<ValueType> {
2018-01-18 13:39:14 +00:00
self.return_type
2018-01-18 12:54:31 +00:00
}
2018-01-18 13:39:14 +00:00
2018-01-23 15:12:41 +00:00
pub(crate) fn from_elements(func_type: &FunctionType) -> Signature {
2018-01-18 13:39:14 +00:00
Signature {
params: func_type.params().iter().cloned().map(ValueType::from_elements).collect(),
return_type: func_type.return_type().map(ValueType::from_elements),
}
}
}
2018-01-23 16:38:49 +00:00
/// Type of a value.
///
/// See [`RuntimeValue`] for details.
2018-01-23 16:38:49 +00:00
///
/// [`RuntimeValue`]: enum.RuntimeValue.html
2018-01-18 13:39:14 +00:00
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum ValueType {
2018-02-01 16:46:33 +00:00
/// 32-bit signed or unsigned integer.
2018-01-18 13:39:14 +00:00
I32,
2018-02-01 16:46:33 +00:00
/// 64-bit signed or unsigned integer.
2018-01-18 13:39:14 +00:00
I64,
2018-02-01 16:46:33 +00:00
/// 32-bit IEEE 754-2008 floating point number.
2018-01-18 13:39:14 +00:00
F32,
2018-02-01 16:46:33 +00:00
/// 64-bit IEEE 754-2008 floating point number.
2018-01-18 13:39:14 +00:00
F64,
2018-01-18 12:54:31 +00:00
}
2018-01-18 13:39:14 +00:00
impl ValueType {
pub(crate) fn from_elements(value_type: EValueType) -> ValueType {
match value_type {
EValueType::I32 => ValueType::I32,
EValueType::I64 => ValueType::I64,
EValueType::F32 => ValueType::F32,
EValueType::F64 => ValueType::F64,
}
}
pub(crate) fn into_elements(self) -> EValueType {
match self {
ValueType::I32 => EValueType::I32,
ValueType::I64 => EValueType::I64,
ValueType::F32 => EValueType::F32,
ValueType::F64 => EValueType::F64,
}
2018-01-18 12:54:31 +00:00
}
}
2018-01-22 13:23:07 +00:00
/// Description of a global variable.
///
/// Primarly used to describe imports of global variables.
/// See [`ImportResolver`] for details.
///
/// [`ImportResolver`]: trait.ImportResolver.html
2018-01-22 13:23:07 +00:00
pub struct GlobalDescriptor {
value_type: ValueType,
mutable: bool,
}
impl GlobalDescriptor {
2018-01-22 13:30:13 +00:00
pub(crate) fn from_elements(global_type: &GlobalType) -> GlobalDescriptor {
2018-01-22 13:23:07 +00:00
GlobalDescriptor {
value_type: ValueType::from_elements(global_type.content_type()),
mutable: global_type.is_mutable(),
}
}
2018-02-01 16:46:33 +00:00
/// Returns [`ValueType`] of the requested global.
///
/// [`ValueType`]: enum.ValueType.html
2018-01-22 13:23:07 +00:00
pub fn value_type(&self) -> ValueType {
self.value_type
}
2018-02-01 16:46:33 +00:00
/// Returns whether the requested global mutable.
2018-01-22 13:23:07 +00:00
pub fn is_mutable(&self) -> bool {
self.mutable
}
2018-01-22 13:30:13 +00:00
}
/// Description of a table.
///
/// Primarly used to describe imports of tables.
/// See [`ImportResolver`] for details.
///
/// [`ImportResolver`]: trait.ImportResolver.html
2018-01-22 13:30:13 +00:00
pub struct TableDescriptor {
initial: u32,
maximum: Option<u32>,
}
impl TableDescriptor {
pub(crate) fn from_elements(table_type: &TableType) -> TableDescriptor {
TableDescriptor {
initial: table_type.limits().initial(),
maximum: table_type.limits().maximum(),
}
}
2018-02-01 16:46:33 +00:00
/// Returns initial size of the requested table.
2018-01-22 13:30:13 +00:00
pub fn initial(&self) -> u32 {
self.initial
}
2018-02-01 16:46:33 +00:00
/// Returns maximum size of the requested table.
2018-01-22 13:30:13 +00:00
pub fn maximum(&self) -> Option<u32> {
self.maximum
}
}
2018-01-22 13:34:32 +00:00
/// Description of a linear memory.
///
/// Primarly used to describe imports of linear memories.
/// See [`ImportResolver`] for details.
///
/// [`ImportResolver`]: trait.ImportResolver.html
2018-01-22 13:34:32 +00:00
pub struct MemoryDescriptor {
initial: u32,
maximum: Option<u32>,
}
impl MemoryDescriptor {
pub(crate) fn from_elements(memory_type: &MemoryType) -> MemoryDescriptor {
MemoryDescriptor {
initial: memory_type.limits().initial(),
maximum: memory_type.limits().maximum(),
}
}
2018-02-01 16:46:33 +00:00
/// Returns initial size (in pages) of the requested memory.
2018-01-22 13:34:32 +00:00
pub fn initial(&self) -> u32 {
self.initial
}
2018-02-01 16:46:33 +00:00
/// Returns maximum size (in pages) of the requested memory.
2018-01-22 13:34:32 +00:00
pub fn maximum(&self) -> Option<u32> {
self.maximum
2018-01-23 15:12:41 +00:00
}
2018-01-22 13:34:32 +00:00
}