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
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::func::FuncRef;
use crate::module::check_limits;
use crate::Error;
use alloc::{rc::Rc, vec::Vec};
use core::cell::RefCell;
use core::fmt;
use core::u32;
use parity_wasm::elements::ResizableLimits;

/// Reference to a table (See [`TableInstance`] for details).
///
/// This reference has a reference-counting semantics.
///
/// [`TableInstance`]: struct.TableInstance.html
///
#[derive(Clone, Debug)]
pub struct TableRef(Rc<TableInstance>);

impl ::core::ops::Deref for TableRef {
    type Target = TableInstance;
    fn deref(&self) -> &TableInstance {
        &self.0
    }
}

/// Runtime representation of a table.
///
/// A table is a array of untyped functions. It allows wasm code to call functions
/// indirectly through a dynamic index into a table. For example, this allows emulating function
/// pointers by way of table indices.
///
/// Table is created with an initial size but can be grown dynamically via [`grow`] method.
/// Growth can be limited by an optional maximum size.
///
/// In future, a table might be extended to be able to hold not only functions but different types.
///
/// [`grow`]: #method.grow
///
pub struct TableInstance {
    /// Table limits.
    limits: ResizableLimits,
    /// Table memory buffer.
    buffer: RefCell<Vec<Option<FuncRef>>>,
}

impl fmt::Debug for TableInstance {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("TableInstance")
            .field("limits", &self.limits)
            .field("buffer.len", &self.buffer.borrow().len())
            .finish()
    }
}

impl TableInstance {
    /// Allocate a table instance.
    ///
    /// The table allocated with initial size, specified by `initial_size`.
    /// Maximum size can be specified by `maximum_size`.
    ///
    /// All table elements are allocated uninitialized.
    ///
    /// # Errors
    ///
    /// Returns `Err` if `initial_size` is greater than `maximum_size`.
    pub fn alloc(initial_size: u32, maximum_size: Option<u32>) -> Result<TableRef, Error> {
        let table = TableInstance::new(ResizableLimits::new(initial_size, maximum_size))?;
        Ok(TableRef(Rc::new(table)))
    }

    fn new(limits: ResizableLimits) -> Result<TableInstance, Error> {
        check_limits(&limits)?;
        Ok(TableInstance {
            buffer: RefCell::new(vec![None; limits.initial() as usize]),
            limits,
        })
    }

    /// Return table limits.
    pub(crate) fn limits(&self) -> &ResizableLimits {
        &self.limits
    }

    /// Returns size this table was created with.
    pub fn initial_size(&self) -> u32 {
        self.limits.initial()
    }

    /// Returns maximum size `TableInstance` can grow to.
    pub fn maximum_size(&self) -> Option<u32> {
        self.limits.maximum()
    }

    /// Returns current size of the table.
    pub fn current_size(&self) -> u32 {
        self.buffer.borrow().len() as u32
    }

    /// Increases the size of the table by given number of elements.
    ///
    /// # Errors
    ///
    /// Returns `Err` if tried to allocate more elements than permited by limit.
    pub fn grow(&self, by: u32) -> Result<(), Error> {
        let mut buffer = self.buffer.borrow_mut();
        let maximum_size = self.maximum_size().unwrap_or(u32::MAX);
        let new_size = self
            .current_size()
            .checked_add(by)
            .and_then(|new_size| {
                if maximum_size < new_size {
                    None
                } else {
                    Some(new_size)
                }
            })
            .ok_or_else(|| {
                Error::Table(format!(
                    "Trying to grow table by {} items when there are already {} items",
                    by,
                    self.current_size(),
                ))
            })?;
        buffer.resize(new_size as usize, None);
        Ok(())
    }

    /// Get the specific value in the table
    pub fn get(&self, offset: u32) -> Result<Option<FuncRef>, Error> {
        let buffer = self.buffer.borrow();
        let buffer_len = buffer.len();
        let table_elem = buffer.get(offset as usize).cloned().ok_or_else(|| {
            Error::Table(format!(
                "trying to read table item with index {} when there are only {} items",
                offset, buffer_len
            ))
        })?;
        Ok(table_elem)
    }

    /// Set the table element to the specified function.
    pub fn set(&self, offset: u32, value: Option<FuncRef>) -> Result<(), Error> {
        let mut buffer = self.buffer.borrow_mut();
        let buffer_len = buffer.len();
        let table_elem = buffer.get_mut(offset as usize).ok_or_else(|| {
            Error::Table(format!(
                "trying to update table item with index {} when there are only {} items",
                offset, buffer_len
            ))
        })?;
        *table_elem = value;
        Ok(())
    }
}