Fixed emscripten

lib/emscripten/src/env/unix/mod.rs

@@ -3,7 +3,6 @@ use libc::{
     c_int, getenv, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, putenv, setenv, sysconf,
     unsetenv,
 };
-use std::cell::Cell;
 use std::ffi::CStr;
 use std::mem;
 use std::os::raw::c_char;
@@ -152,11 +151,7 @@ pub fn _gai_strerror(ctx: &EmEnv, ecode: i32) -> i32 {
     let string_on_guest: WasmPtr<c_char, Array> = call_malloc_with_cast(ctx, bytes.len() as _);
     let memory = ctx.memory(0);
 
-    let writer = unsafe {
-        string_on_guest
-            .deref_mut(&memory, 0, bytes.len() as _)
-            .unwrap()
-    };
+    let writer = string_on_guest.deref(&memory, 0, bytes.len() as _).unwrap();
     for (i, byte) in bytes.iter().enumerate() {
         writer[i].set(*byte as _);
     }
@@ -174,21 +169,23 @@ pub fn _getaddrinfo(
     use libc::{addrinfo, freeaddrinfo};
     debug!("emscripten::_getaddrinfo");
     let memory = ctx.memory(0);
-    debug!(" => node = {}", unsafe {
+    debug!(" => node = {}", {
         node_ptr
             .deref(&memory)
-            .map(|np| {
-                std::ffi::CStr::from_ptr(np as *const Cell<c_char> as *const c_char)
-                    .to_string_lossy()
+            .map(|_np| {
+                // unimplemented!();
+                // std::ffi::CStr::from_ptr(np as *const Cell<c_char> as *const c_char)
+                //     .to_string_lossy()
             })
             .unwrap_or(std::borrow::Cow::Borrowed("null"))
     });
-    debug!(" => server_str = {}", unsafe {
+    debug!(" => server_str = {}", {
         service_str_ptr
             .deref(&memory)
-            .map(|np| {
-                std::ffi::CStr::from_ptr(np as *const Cell<c_char> as *const c_char)
-                    .to_string_lossy()
+            .map(|_np| {
+                unimplemented!();
+                // std::ffi::CStr::from_ptr(np as *const Cell<c_char> as *const c_char)
+                //     .to_string_lossy()
             })
             .unwrap_or(std::borrow::Cow::Borrowed("null"))
     });
@@ -212,13 +209,17 @@ pub fn _getaddrinfo(
     // allocate equivalent memory for res_val_ptr
     let result = unsafe {
         libc::getaddrinfo(
-            (node_ptr
-                .deref(&memory)
-                .map(|m| m as *const Cell<c_char> as *const c_char))
+            (node_ptr.deref(&memory).map(|_m| {
+                unimplemented!();
+                //m as *const Cell<c_char> as *const c_char
+            }))
             .unwrap_or(std::ptr::null()),
             service_str_ptr
                 .deref(&memory)
-                .map(|m| m as *const Cell<c_char> as *const c_char)
+                .map(|_m| {
+                    unimplemented!();
+                    // m as *const Cell<c_char> as *const c_char
+                })
                 .unwrap_or(std::ptr::null()),
             hints
                 .as_ref()
@@ -246,7 +247,7 @@ pub fn _getaddrinfo(
 
             // connect list
             if let Some(prev_guest) = previous_guest_node {
-                let mut pg = prev_guest.deref_mut(&memory).unwrap().get_mut();
+                let mut pg = prev_guest.deref(&memory).unwrap().get_mut();
                 pg.ai_next = current_guest_node_ptr;
             }
 
@@ -258,7 +259,7 @@ pub fn _getaddrinfo(
                 let host_sockaddr_ptr = (*current_host_node).ai_addr;
                 let guest_sockaddr_ptr: WasmPtr<EmSockAddr> =
                     call_malloc_with_cast(ctx, host_addrlen as _);
-                let guest_sockaddr = guest_sockaddr_ptr.deref_mut(&memory).unwrap().get_mut();
+                let guest_sockaddr = guest_sockaddr_ptr.deref(&memory).unwrap().get_mut();
 
                 guest_sockaddr.sa_family = (*host_sockaddr_ptr).sa_family as i16;
                 guest_sockaddr.sa_data = (*host_sockaddr_ptr).sa_data;
@@ -287,8 +288,7 @@ pub fn _getaddrinfo(
                 }
             };
 
-            let mut current_guest_node =
-                current_guest_node_ptr.deref_mut(&memory).unwrap().get_mut();
+            let mut current_guest_node = current_guest_node_ptr.deref(&memory).unwrap().get_mut();
             current_guest_node.ai_flags = (*current_host_node).ai_flags;
             current_guest_node.ai_family = (*current_host_node).ai_family;
             current_guest_node.ai_socktype = (*current_host_node).ai_socktype;

lib/emscripten/src/ptr.rs

@@ -5,8 +5,8 @@
 // don't want to warn about unusued code here
 #![allow(dead_code)]
 
-use std::{cell::Cell, fmt};
-pub use wasmer::{Array, FromToNativeWasmType, Memory, ValueType};
+use std::fmt;
+pub use wasmer::{Array, FromToNativeWasmType, Memory, ValueType, WasmCell};
 
 #[repr(transparent)]
 pub struct WasmPtr<T: Copy, Ty = wasmer::Item>(wasmer::WasmPtr<T, Ty>);
@@ -59,45 +59,27 @@ impl<T: Copy, Ty> WasmPtr<T, Ty> {
 
 impl<T: Copy + ValueType> WasmPtr<T, wasmer::Item> {
     #[inline(always)]
-    pub fn deref<'a>(self, memory: &'a Memory) -> Option<&'a Cell<T>> {
+    pub fn deref<'a>(self, memory: &'a Memory) -> Option<WasmCell<'a, T>> {
         if self.0.offset() == 0 {
             None
         } else {
             self.0.deref(memory)
         }
     }
-
-    #[inline(always)]
-    pub unsafe fn deref_mut<'a>(self, memory: &'a Memory) -> Option<&'a mut Cell<T>> {
-        if self.0.offset() == 0 {
-            None
-        } else {
-            self.0.deref_mut(memory)
-        }
-    }
 }
 
 impl<T: Copy + ValueType> WasmPtr<T, wasmer::Array> {
     #[inline(always)]
-    pub fn deref<'a>(self, memory: &'a Memory, index: u32, length: u32) -> Option<&'a [Cell<T>]> {
-        if self.0.offset() == 0 {
-            None
-        } else {
-            self.0.deref(memory, index, length)
-        }
-    }
-
-    #[inline]
-    pub unsafe fn deref_mut<'a>(
+    pub fn deref<'a>(
         self,
         memory: &'a Memory,
         index: u32,
         length: u32,
-    ) -> Option<&'a mut [Cell<T>]> {
+    ) -> Option<Vec<WasmCell<'a, T>>> {
         if self.0.offset() == 0 {
             None
         } else {
-            self.0.deref_mut(memory, index, length)
+            self.0.deref(memory, index, length)
         }
     }
 

lib/emscripten/src/syscalls/unix.rs

@@ -633,7 +633,7 @@ pub fn ___syscall102(ctx: &EmEnv, _which: c_int, mut varargs: VarArgs) -> c_int
                 address.deref(&memory).unwrap().get(),
                 address_len.deref(&memory).unwrap().get()
             );
-            let address_len_addr = unsafe { address_len.deref_mut(&memory).unwrap().get_mut() };
+            let address_len_addr = unsafe { address_len.deref(&memory).unwrap().get_mut() };
             // let mut address_len_addr: socklen_t = 0;
 
             let mut host_address: sockaddr = sockaddr {
@@ -643,7 +643,7 @@ pub fn ___syscall102(ctx: &EmEnv, _which: c_int, mut varargs: VarArgs) -> c_int
                 sa_len: Default::default(),
             };
             let fd = unsafe { accept(socket, &mut host_address, address_len_addr) };
-            let address_addr = unsafe { address.deref_mut(&memory).unwrap().get_mut() };
+            let address_addr = unsafe { address.deref(&memory).unwrap().get_mut() };
 
             address_addr.sa_family = host_address.sa_family as _;
             address_addr.sa_data = host_address.sa_data;
@@ -667,7 +667,7 @@ pub fn ___syscall102(ctx: &EmEnv, _which: c_int, mut varargs: VarArgs) -> c_int
             let socket: i32 = socket_varargs.get(ctx);
             let address: WasmPtr<EmSockAddr> = socket_varargs.get(ctx);
             let address_len: WasmPtr<u32> = socket_varargs.get(ctx);
-            let address_len_addr = unsafe { address_len.deref_mut(&memory).unwrap().get_mut() };
+            let address_len_addr = unsafe { address_len.deref(&memory).unwrap().get_mut() };
 
             let mut sock_addr_host: sockaddr = sockaddr {
                 sa_family: Default::default(),
@@ -683,7 +683,7 @@ pub fn ___syscall102(ctx: &EmEnv, _which: c_int, mut varargs: VarArgs) -> c_int
                 )
             };
             // translate from host data into emscripten data
-            let mut address_mut = unsafe { address.deref_mut(&memory).unwrap().get_mut() };
+            let mut address_mut = unsafe { address.deref(&memory).unwrap().get_mut() };
             address_mut.sa_family = sock_addr_host.sa_family as _;
             address_mut.sa_data = sock_addr_host.sa_data;
 
@@ -857,7 +857,7 @@ pub fn ___syscall168(ctx: &EmEnv, _which: i32, mut varargs: VarArgs) -> i32 {
     let timeout: i32 = varargs.get(ctx);
     let memory = ctx.memory(0);
 
-    let fds_mut = unsafe { fds.deref_mut(&memory).unwrap().get_mut() };
+    let fds_mut = unsafe { fds.deref(&memory).unwrap().get_mut() };
 
     let ret = unsafe {
         libc::poll(