Make Store Send and Sync (#566)

* make Arena<Idx, T> Send and Sync independent of Idx

* make InstructionPtr Send but not Sync

* add compile-time test to assert that Store is Send + Sync if T: Send+Sync

* add more docs to unsafe Send impl of InstructionPtr

* apply rustfmt

crates/arena/src/lib.rs

@@ -54,6 +54,12 @@ pub struct Arena<Idx, T> {
     marker: PhantomData<Idx>,
 }
 
+/// `Arena` does not store `Idx` therefore it is `Send` without its bound.
+unsafe impl<Idx, T> Send for Arena<Idx, T> where T: Send {}
+
+/// `Arena` does not store `Idx` therefore it is `Sync` without its bound.
+unsafe impl<Idx, T> Sync for Arena<Idx, T> where T: Send {}
+
 impl<Idx, T> Default for Arena<Idx, T> {
     fn default() -> Self {
         Self::new()

crates/wasmi/src/engine/code_map.rs

@@ -139,6 +139,16 @@ pub struct InstructionPtr {
     ptr: *const Instruction,
 }
 
+/// It is safe to send an [`InstructionPtr`] to another thread.
+///
+/// The access to the pointed-to [`Instruction`] is read-only and
+/// [`Instruction`] itself is [`Send`].
+///
+/// However, it is not safe to share an [`InstructionPtr`] between threads
+/// due to their [`InstructionPtr::offset`] method which relinks the
+/// internal pointer and is not synchronized.
+unsafe impl Send for InstructionPtr {}
+
 impl InstructionPtr {
     /// Creates a new [`InstructionPtr`] for `instr`.
     #[inline]

crates/wasmi/src/store.rs

@@ -80,6 +80,16 @@ pub struct Store<T> {
     user_state: T,
 }
 
+#[test]
+fn test_store_is_send_sync() {
+    const _: () = {
+        fn assert_send<T: Send>() {}
+        fn assert_sync<T: Sync>() {}
+        let _ = assert_send::<Store<()>>;
+        let _ = assert_sync::<Store<()>>;
+    };
+}
+
 impl<T> Store<T> {
     /// Creates a new store.
     pub fn new(engine: &Engine, user_state: T) -> Self {