diff --git a/src/lib/libsigs.js b/src/lib/libsigs.js
index 4b19dec546636..314dbda467325 100644
--- a/src/lib/libsigs.js
+++ b/src/lib/libsigs.js
@@ -230,11 +230,11 @@ sigs = {
   __pthread_create_js__sig: 'ipppp',
   __resumeException__sig: 'vp',
   __syscall__newselect__sig: 'iipppp',
-  __syscall_accept4__sig: 'iippiii',
-  __syscall_bind__sig: 'iippiii',
+  __syscall_accept4__sig: 'iippip',
+  __syscall_bind__sig: 'iipip',
   __syscall_chdir__sig: 'ip',
   __syscall_chmod__sig: 'ipi',
-  __syscall_connect__sig: 'iippiii',
+  __syscall_connect__sig: 'iipip',
   __syscall_dup__sig: 'ii',
   __syscall_dup3__sig: 'iiii',
   __syscall_faccessat__sig: 'iipii',
@@ -252,27 +252,27 @@ sigs = {
   __syscall_ftruncate64__sig: 'iij',
   __syscall_getcwd__sig: 'ipp',
   __syscall_getdents64__sig: 'iipp',
-  __syscall_getpeername__sig: 'iippiii',
-  __syscall_getsockname__sig: 'iippiii',
-  __syscall_getsockopt__sig: 'iiiippi',
+  __syscall_getpeername__sig: 'iippp',
+  __syscall_getsockname__sig: 'iippp',
+  __syscall_getsockopt__sig: 'iiiippp',
   __syscall_ioctl__sig: 'iiip',
-  __syscall_listen__sig: 'iiiiiii',
+  __syscall_listen__sig: 'iiip',
   __syscall_lstat64__sig: 'ipp',
   __syscall_mkdirat__sig: 'iipi',
   __syscall_mknodat__sig: 'iipii',
   __syscall_newfstatat__sig: 'iippi',
   __syscall_openat__sig: 'iipip',
   __syscall_pipe__sig: 'ip',
-  __syscall_poll__sig: 'ipii',
+  __syscall_poll__sig: 'ippi',
   __syscall_readlinkat__sig: 'iippp',
-  __syscall_recvfrom__sig: 'iippipp',
-  __syscall_recvmsg__sig: 'iipiiii',
+  __syscall_recvfrom__sig: 'pippipp',
+  __syscall_recvmsg__sig: 'pipip',
   __syscall_renameat__sig: 'iipip',
   __syscall_rmdir__sig: 'ip',
-  __syscall_sendmsg__sig: 'iipippi',
-  __syscall_sendto__sig: 'iippipp',
-  __syscall_shutdown__sig: 'iiiiiii',
-  __syscall_socket__sig: 'iiiiiii',
+  __syscall_sendmsg__sig: 'pipip',
+  __syscall_sendto__sig: 'pippipi',
+  __syscall_shutdown__sig: 'iiip',
+  __syscall_socket__sig: 'iiiip',
   __syscall_stat64__sig: 'ipp',
   __syscall_statfs64__sig: 'ippp',
   __syscall_symlinkat__sig: 'ipip',
diff --git a/src/lib/libsyscall.js b/src/lib/libsyscall.js
index 61af4001bd53f..6c6b8e537ffa3 100644
--- a/src/lib/libsyscall.js
+++ b/src/lib/libsyscall.js
@@ -345,7 +345,7 @@ var SyscallsLibrary = {
     return info;
   },
   __syscall_socket__deps: ['$SOCKFS'],
-  __syscall_socket: (domain, type, protocol) => {
+  __syscall_socket: (domain, type, protocol, varargs) => {
     var sock = SOCKFS.createSocket(domain, type, protocol);
 #if ASSERTIONS
     assert(sock.stream.fd < 64); // XXX ? select() assumes socket fd values are in 0..63
@@ -353,7 +353,7 @@ var SyscallsLibrary = {
     return sock.stream.fd;
   },
   __syscall_getsockname__deps: ['$getSocketFromFD', '$writeSockaddr', '$DNS'],
-  __syscall_getsockname: (fd, addr, addrlen, d1, d2, d3) => {
+  __syscall_getsockname: (fd, addr, addrlen, varargs) => {
     var sock = getSocketFromFD(fd);
     // TODO: sock.saddr should never be undefined, see TODO in websocket_sock_ops.getname
     var errno = writeSockaddr(addr, sock.family, DNS.lookup_name(sock.saddr || '0.0.0.0'), sock.sport, addrlen);
@@ -363,7 +363,7 @@ var SyscallsLibrary = {
     return 0;
   },
   __syscall_getpeername__deps: ['$getSocketFromFD', '$writeSockaddr', '$DNS'],
-  __syscall_getpeername: (fd, addr, addrlen, d1, d2, d3) => {
+  __syscall_getpeername: (fd, addr, addrlen, varargs) => {
     var sock = getSocketFromFD(fd);
     if (!sock.daddr) {
       return -{{{ cDefs.ENOTCONN }}}; // The socket is not connected.
@@ -375,19 +375,19 @@ var SyscallsLibrary = {
     return 0;
   },
   __syscall_connect__deps: ['$getSocketFromFD', '$getSocketAddress'],
-  __syscall_connect: (fd, addr, addrlen, d1, d2, d3) => {
+  __syscall_connect: (fd, addr, addrlen, varargs) => {
     var sock = getSocketFromFD(fd);
     var info = getSocketAddress(addr, addrlen);
     sock.sock_ops.connect(sock, info.addr, info.port);
     return 0;
   },
   __syscall_shutdown__deps: ['$getSocketFromFD'],
-  __syscall_shutdown: (fd, how) => {
+  __syscall_shutdown: (fd, how, varargs) => {
     getSocketFromFD(fd);
     return -{{{ cDefs.ENOSYS }}}; // unsupported feature
   },
   __syscall_accept4__deps: ['$getSocketFromFD', '$writeSockaddr', '$DNS'],
-  __syscall_accept4: (fd, addr, addrlen, flags, d1, d2) => {
+  __syscall_accept4: (fd, addr, addrlen, flags, varargs) => {
     var sock = getSocketFromFD(fd);
     var newsock = sock.sock_ops.accept(sock);
     if (addr) {
@@ -399,14 +399,14 @@ var SyscallsLibrary = {
     return newsock.stream.fd;
   },
   __syscall_bind__deps: ['$getSocketFromFD', '$getSocketAddress'],
-  __syscall_bind: (fd, addr, addrlen, d1, d2, d3) => {
+  __syscall_bind: (fd, addr, addrlen, varargs) => {
     var sock = getSocketFromFD(fd);
     var info = getSocketAddress(addr, addrlen);
     sock.sock_ops.bind(sock, info.addr, info.port);
     return 0;
   },
   __syscall_listen__deps: ['$getSocketFromFD'],
-  __syscall_listen: (fd, backlog) => {
+  __syscall_listen: (fd, backlog, varargs) => {
     var sock = getSocketFromFD(fd);
     sock.sock_ops.listen(sock, backlog);
     return 0;
@@ -437,7 +437,7 @@ var SyscallsLibrary = {
     return sock.sock_ops.sendmsg(sock, HEAP8, message, length, dest.addr, dest.port);
   },
   __syscall_getsockopt__deps: ['$getSocketFromFD'],
-  __syscall_getsockopt: (fd, level, optname, optval, optlen, d1) => {
+  __syscall_getsockopt: (fd, level, optname, optval, optlen, varargs) => {
     var sock = getSocketFromFD(fd);
     // Minimal getsockopt aimed at resolving https://github.com/emscripten-core/emscripten/issues/2211
     // so only supports SOL_SOCKET with SO_ERROR.
@@ -452,7 +452,7 @@ var SyscallsLibrary = {
     return -{{{ cDefs.ENOPROTOOPT }}}; // The option is unknown at the level indicated.
   },
   __syscall_sendmsg__deps: ['$getSocketFromFD', '$getSocketAddress'],
-  __syscall_sendmsg: (fd, message, flags, d1, d2, d3) => {
+  __syscall_sendmsg: (fd, message, flags, varargs) => {
     var sock = getSocketFromFD(fd);
     var iov = {{{ makeGetValue('message', C_STRUCTS.msghdr.msg_iov, '*') }}};
     var num = {{{ makeGetValue('message', C_STRUCTS.msghdr.msg_iovlen, 'i32') }}};
@@ -483,7 +483,7 @@ var SyscallsLibrary = {
     return sock.sock_ops.sendmsg(sock, view, 0, total, addr, port);
   },
   __syscall_recvmsg__deps: ['$getSocketFromFD', '$writeSockaddr', '$DNS'],
-  __syscall_recvmsg: (fd, message, flags, d1, d2, d3) => {
+  __syscall_recvmsg: (fd, message, flags, varargs) => {
     var sock = getSocketFromFD(fd);
     var iov = {{{ makeGetValue('message', C_STRUCTS.msghdr.msg_iov, '*') }}};
     var num = {{{ makeGetValue('message', C_STRUCTS.msghdr.msg_iovlen, 'i32') }}};
diff --git a/system/lib/libc/emscripten_internal.h b/system/lib/libc/emscripten_internal.h
index 6b6eb97693ab9..23f5455111fc3 100644
--- a/system/lib/libc/emscripten_internal.h
+++ b/system/lib/libc/emscripten_internal.h
@@ -76,9 +76,9 @@ int _mmap_js(size_t length,
              int* allocated,
              void** addr);
 int _munmap_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset);
+  void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 int _msync_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset);
+  void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 
 struct dso;
 
diff --git a/system/lib/libc/emscripten_mmap.c b/system/lib/libc/emscripten_mmap.c
index 7281d5b8baebe..44cbb86e477a9 100644
--- a/system/lib/libc/emscripten_mmap.c
+++ b/system/lib/libc/emscripten_mmap.c
@@ -35,10 +35,10 @@ struct map {
 static volatile int lock[1];
 static struct map* mappings;
 
-static struct map* find_mapping(intptr_t addr, struct map** prev) {
+static struct map* find_mapping(void *addr, struct map** prev) {
   struct map* map = mappings;
   while (map) {
-    if (map->addr == (void*)addr) {
+    if (map->addr == addr) {
       return map;
     }
     if (prev) {
@@ -49,7 +49,7 @@ static struct map* find_mapping(intptr_t addr, struct map** prev) {
   return map;
 }
 
-int __syscall_munmap(intptr_t addr, size_t length) {
+int __syscall_munmap(void *addr, size_t length) {
   LOCK(lock);
   struct map* prev = NULL;
   struct map* map = find_mapping(addr, &prev);
@@ -89,7 +89,7 @@ int __syscall_munmap(intptr_t addr, size_t length) {
   return 0;
 }
 
-int __syscall_msync(intptr_t addr, size_t len, int flags) {
+int __syscall_msync(void *addr, size_t len, int flags) {
   LOCK(lock);
   struct map* map = find_mapping(addr, NULL);
   UNLOCK(lock);
@@ -102,7 +102,7 @@ int __syscall_msync(intptr_t addr, size_t len, int flags) {
   return _msync_js(addr, len, map->prot, map->flags, map->fd, map->offset);
 }
 
-intptr_t __syscall_mmap2(intptr_t addr, size_t len, int prot, int flags, int fd, off_t offset) {
+intptr_t __syscall_mmap2(void *addr, size_t len, int prot, int flags, int fd, off_t offset) {
   if (addr != 0) {
     // We don't currently support location hints for the address of the mapping
     return -EINVAL;
@@ -147,5 +147,5 @@ intptr_t __syscall_mmap2(intptr_t addr, size_t len, int prot, int flags, int fd,
   mappings = new_map;
   UNLOCK(lock);
 
-  return (long)new_map->addr;
+  return (intptr_t)new_map->addr;
 }
diff --git a/system/lib/libc/emscripten_syscall_stubs.c b/system/lib/libc/emscripten_syscall_stubs.c
index ca7e5be6eea10..4ac0ffee41b58 100644
--- a/system/lib/libc/emscripten_syscall_stubs.c
+++ b/system/lib/libc/emscripten_syscall_stubs.c
@@ -11,24 +11,18 @@
  * 3. Return ENOSYS and warn at runtime if called.
  */
 
+#define _GNU_SOURCE // for struct mmsghdr
 #include <errno.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <syscall_arch.h>
 #include <string.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <sys/utsname.h>
+#include <syscall_arch.h>
 #include <emscripten/console.h>
 #include <emscripten/version.h>
 #include <emscripten/stack.h>
 
-static int g_pid = 42;
-static int g_pgid = 42;
-static int g_ppid = 1;
-static int g_sid = 42;
+static pid_t g_pid = 42;
+static pid_t g_pgid = 42;
+static pid_t g_ppid = 1;
+static pid_t g_sid = 42;
 static mode_t g_umask = S_IWGRP | S_IWOTH;
 
 #ifdef NDEBUG
@@ -47,7 +41,7 @@ static mode_t g_umask = S_IWGRP | S_IWOTH;
 #define STRINGIFY(s) #s
 #define STR(s) STRINGIFY(s)
 
-weak int __syscall_uname(intptr_t buf) {
+weak int __syscall_uname(struct utsname *buf) {
   if (!buf) {
     return -EFAULT;
   }
@@ -55,21 +49,19 @@ weak int __syscall_uname(intptr_t buf) {
                              STR(__EMSCRIPTEN_minor__) "." \
                              STR(__EMSCRIPTEN_tiny__);
 
-  struct utsname *utsname = (struct utsname *)buf;
-
-  strcpy(utsname->sysname, "Emscripten");
-  strcpy(utsname->nodename, "emscripten");
-  strcpy(utsname->release, full_version);
-  strcpy(utsname->version, "#1");
+  strcpy(buf->sysname, "Emscripten");
+  strcpy(buf->nodename, "emscripten");
+  strcpy(buf->release, full_version);
+  strcpy(buf->version, "#1");
 #ifdef __wasm64__
-  strcpy(utsname->machine, "wasm64");
+  strcpy(buf->machine, "wasm64");
 #else
-  strcpy(utsname->machine, "wasm32");
+  strcpy(buf->machine, "wasm32");
 #endif
   return 0;
 }
 
-weak int __syscall_setpgid(int pid, int pgid) {
+weak int __syscall_setpgid(pid_t pid, pid_t pgid) {
   if (pid && pid != g_pid) {
     return -ESRCH;
   }
@@ -83,46 +75,46 @@ weak int __syscall_sync() {
   return 0;
 }
 
-weak int __syscall_getsid(int pid) {
+weak pid_t __syscall_getsid(pid_t pid) {
   if (pid && pid != g_pid) {
     return -ESRCH;
   }
   return g_sid;
 }
 
-weak int __syscall_getpgid(int pid) {
+weak pid_t __syscall_getpgid(pid_t pid) {
   if (pid && pid != g_pid) {
     return -ESRCH;
   }
   return g_pgid;
 }
 
-weak int __syscall_getpid() {
+weak pid_t __syscall_getpid() {
   return g_pid;
 }
 
-weak int __syscall_getppid() {
+weak pid_t __syscall_getppid() {
   return g_ppid;
 }
 
-weak int __syscall_linkat(int olddirfd, intptr_t oldpath, int newdirfd, intptr_t newpath, int flags) {
+weak int __syscall_linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags) {
   return -EMLINK; // no hardlinks for us
 }
 
-weak int __syscall_getgroups32(int size, intptr_t list) {
-  if (size < 1) {
+weak int __syscall_getgroups32(int count, gid_t list[]) {
+  if (count < 1) {
     return -EINVAL;
   }
-  ((gid_t*)list)[0] = 0;
+  list[0] = 0;
   return 1;
 }
 
-weak int __syscall_setsid() {
+weak pid_t __syscall_setsid() {
   return 0; // no-op
 }
 
-weak int __syscall_umask(int mask) {
-  int old = g_umask;
+weak mode_t __syscall_umask(mode_t mask) {
+  mode_t old = g_umask;
   g_umask = mask;
   return old;
 }
@@ -134,7 +126,7 @@ struct kusage {
   long stime_tv_usec;
 };
 
-weak int __syscall_getrusage(int who, intptr_t usage) {
+weak int __syscall_getrusage(int who, void *usage) {
   REPORT(getrusage);
   struct kusage *u = (struct kusage*)usage;
   u->utime_tv_sec = 1;
@@ -144,46 +136,46 @@ weak int __syscall_getrusage(int who, intptr_t usage) {
   return 0;
 }
 
-weak int __syscall_getpriority(int which, int who) {
+weak int __syscall_getpriority(int which, id_t who) {
   return 0;
 }
 
-weak int __syscall_setpriority(int which, int who, int prio) {
+weak int __syscall_setpriority(int which, id_t who, int prio) {
   return -EPERM;
 }
 
-weak int __syscall_setdomainname(intptr_t name, size_t size) {
+weak int __syscall_setdomainname(const char *name, size_t len) {
   return -EPERM;
 }
 
-weak int __syscall_getuid32(void) {
+weak uid_t __syscall_getuid32(void) {
   return 0;
 }
 
-weak int __syscall_getgid32(void) {
+weak gid_t __syscall_getgid32(void) {
   return 0;
 }
 
-weak int __syscall_geteuid32(void) {
+weak uid_t __syscall_geteuid32(void) {
   return 0;
 }
 
-weak int __syscall_getegid32(void) {
+weak gid_t __syscall_getegid32(void) {
   return 0;
 }
 
-weak int __syscall_getresuid32(intptr_t ruid, intptr_t euid, intptr_t suid) {
-  *((uid_t *)ruid) = 0;
-  *((uid_t *)euid) = 0;
-  *((uid_t *)suid) = 0;
+weak int __syscall_getresuid32(uid_t *ruid, uid_t *euid, uid_t *suid) {
+  *ruid = 0;
+  *euid = 0;
+  *suid = 0;
   return 0;
 }
 
-weak int __syscall_getresgid32(intptr_t ruid, intptr_t euid, intptr_t suid) {
+weak int __syscall_getresgid32(gid_t *rgid, gid_t *egid, gid_t *sgid) {
   REPORT(getresgid32);
-  *((uid_t *)ruid) = 0;
-  *((uid_t *)euid) = 0;
-  *((uid_t *)suid) = 0;
+  *rgid = 0;
+  *egid = 0;
+  *sgid = 0;
   return 0;
 }
 
@@ -192,28 +184,28 @@ weak int __syscall_pause() {
   return -EINTR; // we can't pause
 }
 
-weak int __syscall_madvise(intptr_t addr, size_t length, int advice) {
+weak int __syscall_madvise(void *addr, size_t length, int advice) {
   REPORT(madvise);
   // advice is welcome, but ignored
   return 0;
 }
 
-weak int __syscall_mlock(intptr_t addr, size_t len) {
+weak int __syscall_mlock(const void *addr, size_t len) {
   REPORT(mlock);
   return 0;
 }
 
-weak int __syscall_munlock(intptr_t addr, size_t len) {
+weak int __syscall_munlock(const void *addr, size_t len) {
   REPORT(munlock);
   return 0;
 }
 
-weak int __syscall_mprotect(size_t addr, size_t len, int prot) {
+weak int __syscall_mprotect(size_t start, size_t len, int prot) {
   REPORT(mprotect);
   return 0; // let's not and say we did
 }
 
-weak int __syscall_mremap(intptr_t old_addr, size_t old_size, size_t new_size, int flags, intptr_t new_addr) {
+weak int __syscall_mremap(void *old_addr, size_t old_size, size_t new_size, int flags, void *new_addr) {
   REPORT(mremap);
   return -ENOMEM; // never succeed
 }
@@ -228,44 +220,47 @@ weak int __syscall_munlockall() {
   return 0;
 }
 
-weak int __syscall_prlimit64(int pid, int resource, intptr_t new_limit, intptr_t old_limit) {
+weak int __syscall_prlimit64(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit) {
   REPORT(prlimit64);
-  struct rlimit *old = (struct rlimit *)old_limit;
   if (new_limit) {
     return -EPERM;
   }
-  if (old) {
+  if (old_limit) {
     if (resource == RLIMIT_NOFILE) {
       // See FS.MAX_OPEN_FDS in src/lib/libfs.js
-      old->rlim_cur = 4096;
-      old->rlim_max = 4096;
+      old_limit->rlim_cur = 4096;
+      old_limit->rlim_max = 4096;
     } else if (resource == RLIMIT_STACK) {
       uintptr_t end = emscripten_stack_get_end();
       uintptr_t base = emscripten_stack_get_base();
 
-      old->rlim_cur = base - end;
+      old_limit->rlim_cur = base - end;
       // we can not change the stack size, so the maximum is the same as the current
-      old->rlim_max = base - end;
+      old_limit->rlim_max = base - end;
     } else {
       // Just report no limits
-      old->rlim_cur = RLIM_INFINITY;
-      old->rlim_max = RLIM_INFINITY;
+      old_limit->rlim_cur = RLIM_INFINITY;
+      old_limit->rlim_max = RLIM_INFINITY;
     }
   }
   return 0;
 }
 
-weak int __syscall_setsockopt(int sockfd, int level, int optname, intptr_t optval, size_t optlen, int dummy) {
+weak int __syscall_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen, ...) {
   REPORT(setsockopt);
   return -ENOPROTOOPT; // The option is unknown at the level indicated.
 }
 
-UNIMPLEMENTED(acct, (intptr_t filename))
-UNIMPLEMENTED(mincore, (intptr_t addr, size_t length, intptr_t vec))
-UNIMPLEMENTED(pipe2, (intptr_t fds, int flags))
-UNIMPLEMENTED(pselect6, (int nfds, intptr_t readfds, intptr_t writefds, intptr_t exceptfds, intptr_t timeout, intptr_t sigmaks))
-UNIMPLEMENTED(recvmmsg, (int sockfd, intptr_t msgvec, size_t vlen, int flags, ...))
-UNIMPLEMENTED(sendmmsg, (int sockfd, intptr_t msgvec, size_t vlen, int flags, ...))
-UNIMPLEMENTED(shutdown, (int sockfd, int how, int dummy, int dummy2, int dummy3, int dummy4))
-UNIMPLEMENTED(socketpair, (int domain, int type, int protocol, intptr_t fds, int dummy, int dummy2))
-UNIMPLEMENTED(wait4,(int pid, intptr_t wstatus, int options, int rusage))
+weak pid_t __syscall_wait4(pid_t pid, int *wstatus, int options, void *rusage) {
+  REPORT(wait4);
+  return (pid_t)-1;
+}
+
+UNIMPLEMENTED(acct, (const char *filename))
+UNIMPLEMENTED(mincore, (void *addr, size_t length, unsigned char *vec))
+UNIMPLEMENTED(pipe2, (int pipefd[2], int flags))
+UNIMPLEMENTED(pselect6, (int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, const long ts[2], const void *mask))
+UNIMPLEMENTED(recvmmsg, (int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags, struct timespec *timeout))
+UNIMPLEMENTED(sendmmsg, (int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags))
+UNIMPLEMENTED(shutdown, (int sockfd, int how, ...))
+UNIMPLEMENTED(socketpair, (int domain, int type, int protocol, int fd[2], ...))
diff --git a/system/lib/libc/musl/arch/emscripten/syscall_arch.h b/system/lib/libc/musl/arch/emscripten/syscall_arch.h
index 8076adad04e96..b70093f5d6aae 100644
--- a/system/lib/libc/musl/arch/emscripten/syscall_arch.h
+++ b/system/lib/libc/musl/arch/emscripten/syscall_arch.h
@@ -1,4 +1,12 @@
+#include <poll.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
 #include <sys/types.h>
+#include <sys/utsname.h>
+
 #include <wasi/api.h>
 #include <wasi/wasi-helpers.h>
 
@@ -12,108 +20,108 @@
 extern "C" {
 #endif
 
-int __syscall_chdir(intptr_t path);
-int __syscall_mknod(intptr_t path, int mode, int dev);
-int __syscall_chmod(intptr_t path, int mode);
-int __syscall_getpid(void);
+int __syscall_chdir(const char *path);
+int __syscall_mknod(const char *path, mode_t mode, dev_t dev);
+int __syscall_chmod(const char *path, mode_t mode);
+pid_t __syscall_getpid(void);
 int __syscall_pause(void);
-int __syscall_access(intptr_t path, int amode);
+int __syscall_access(const char *path, int amode);
 int __syscall_sync(void);
-int __syscall_rmdir(intptr_t path);
+int __syscall_rmdir(const char *path);
 int __syscall_dup(int fd);
-int __syscall_pipe(intptr_t fd);
-int __syscall_acct(intptr_t filename);
+int __syscall_pipe(int fd[2]);
+int __syscall_acct(const char *filename);
 int __syscall_ioctl(int fd, int request, ...);
-int __syscall_setpgid(int pid, int gpid);
-int __syscall_umask(int mask);
-int __syscall_getppid(void);
-int __syscall_getpgrp(void);
-int __syscall_setsid(void);
-int __syscall_getrusage(int who, intptr_t usage);
-int __syscall_munmap(intptr_t addr, size_t len);
-int __syscall_fchmod(int fd, int mode);
-int __syscall_getpriority(int which, int who);
-int __syscall_setpriority(int which, int who, int prio);
-int __syscall_socketcall(int call, intptr_t args);
-int __syscall_wait4(int pid, intptr_t wstatus, int options, int rusage);
-int __syscall_setdomainname(intptr_t name, size_t size);
-int __syscall_uname(intptr_t buf);
-int __syscall_mprotect(size_t addr, size_t len, int prot);
-int __syscall_getpgid(int pid);
+int __syscall_setpgid(pid_t pid, pid_t gpid);
+mode_t __syscall_umask(mode_t mask);
+pid_t __syscall_getppid(void);
+pid_t __syscall_getpgrp(void);
+pid_t __syscall_setsid(void);
+int __syscall_getrusage(int who, /* struct rusage *usage */void *usage);
+int __syscall_munmap(void *addr, size_t len);
+int __syscall_fchmod(int fd, mode_t mode);
+int __syscall_getpriority(int which, id_t who);
+int __syscall_setpriority(int which, id_t who, int prio);
+int __syscall_socketcall(int call, long args[6]);
+pid_t __syscall_wait4(pid_t pid, int *wstatus, int options, /* struct rusage *rusage */void *rusage);
+int __syscall_setdomainname(const char *name, size_t len);
+int __syscall_uname(struct utsname *buf);
+int __syscall_mprotect(size_t start, size_t len, int prot);
+pid_t __syscall_getpgid(pid_t pid);
 int __syscall_fchdir(int fd);
-int __syscall__newselect(int nfds, intptr_t readfds, intptr_t writefds, intptr_t exceptfds, intptr_t timeout);
-int __syscall_msync(intptr_t addr, size_t len, int flags);
-int __syscall_getsid(int pid);
+int __syscall__newselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, /* struct timeval *timeout */long timeout[2]);
+int __syscall_msync(void *addr, size_t len, int flags);
+pid_t __syscall_getsid(pid_t pid);
 int __syscall_fdatasync(int fd);
-int __syscall_mlock(intptr_t addr, size_t len);
-int __syscall_munlock(intptr_t addr, size_t len);
+int __syscall_mlock(const void *addr, size_t len);
+int __syscall_munlock(const void *addr, size_t len);
 int __syscall_mlockall(int flags);
 int __syscall_munlockall(void);
-int __syscall_mremap(intptr_t old_addr, size_t old_size, size_t new_size, int flags, intptr_t new_addr);
-int __syscall_poll(intptr_t fds, int nfds, int timeout);
-int __syscall_getcwd(intptr_t buf, size_t size);
-intptr_t __syscall_mmap2(intptr_t addr, size_t len, int prot, int flags, int fd, off_t offset);
-int __syscall_truncate64(intptr_t path, off_t length);
+int __syscall_mremap(void *old_addr, size_t old_size, size_t new_size, int flags, void *new_addr);
+int __syscall_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+int __syscall_getcwd(char *buf, size_t size);
+intptr_t __syscall_mmap2(void *addr, size_t len, int prot, int flags, int fd, off_t offset);
+int __syscall_truncate64(const char *path, off_t length);
 int __syscall_ftruncate64(int fd, off_t length);
-int __syscall_stat64(intptr_t path, intptr_t buf);
-int __syscall_lstat64(intptr_t path, intptr_t buf);
-int __syscall_fstat64(int fd, intptr_t buf);
-int __syscall_getuid32(void);
-int __syscall_getgid32(void);
-int __syscall_geteuid32(void);
-int __syscall_getegid32(void);
-int __syscall_setreuid32(int ruid, int euid);
-int __syscall_setregid32(int rgid, int egid);
-int __syscall_getgroups32(int size, intptr_t list);
-int __syscall_fchown32(int fd, int owner, int group);
-int __syscall_setresuid32(int ruid, int euid, int suid);
-int __syscall_getresuid32(intptr_t ruid, intptr_t euid, intptr_t suid);
-int __syscall_setresgid32(int rgid, int egid, int sgid);
-int __syscall_getresgid32(intptr_t rgid, intptr_t egid, intptr_t sgid);
-int __syscall_setuid32(int uid);
-int __syscall_setgid32(int uid);
-int __syscall_mincore(intptr_t addr, size_t length, intptr_t vec);
-int __syscall_madvise(intptr_t addr, size_t length, int advice);
-int __syscall_getdents64(int fd, intptr_t dirp, size_t count);
+int __syscall_stat64(const char *path, struct stat *buf);
+int __syscall_lstat64(const char *path, struct stat *buf);
+int __syscall_fstat64(int fd, struct stat *buf);
+uid_t __syscall_getuid32(void);
+gid_t __syscall_getgid32(void);
+uid_t __syscall_geteuid32(void);
+gid_t __syscall_getegid32(void);
+int __syscall_setreuid32(uid_t ruid, uid_t euid);
+int __syscall_setregid32(gid_t rgid, gid_t egid);
+int __syscall_getgroups32(int count, gid_t list[]);
+int __syscall_fchown32(int fd, uid_t owner, gid_t group);
+int __syscall_setresuid32(uid_t ruid, uid_t euid, uid_t suid);
+int __syscall_getresuid32(uid_t *ruid, uid_t *euid, uid_t *suid);
+int __syscall_setresgid32(gid_t rgid, gid_t egid, gid_t sgid);
+int __syscall_getresgid32(gid_t *rgid, gid_t *egid, gid_t *sgid);
+int __syscall_setuid32(uid_t uid);
+int __syscall_setgid32(gid_t gid);
+int __syscall_mincore(void *addr, size_t length, unsigned char *vec);
+int __syscall_madvise(void *addr, size_t length, int advice);
+int __syscall_getdents64(int fd, /* struct dirent *dirp */void *dirp, size_t count);
 int __syscall_fcntl64(int fd, int cmd, ...);
-int __syscall_statfs64(intptr_t path, size_t size, intptr_t buf);
-int __syscall_fstatfs64(int fd, size_t size, intptr_t buf);
-int __syscall_fadvise64(int fd, off_t offset, off_t length, int advice);
-int __syscall_openat(int dirfd, intptr_t path, int flags, ...); // mode is optional
-int __syscall_mkdirat(int dirfd, intptr_t path, int mode);
-int __syscall_mknodat(int dirfd, intptr_t path, int mode, int dev);
-int __syscall_fchownat(int dirfd, intptr_t path, int owner, int group, int flags);
-int __syscall_newfstatat(int dirfd, intptr_t path, intptr_t buf, int flags);
-int __syscall_unlinkat(int dirfd, intptr_t path, int flags);
-int __syscall_renameat(int olddirfd, intptr_t oldpath, int newdirfd, intptr_t newpath);
-int __syscall_linkat(int olddirfd, intptr_t oldpath, int newdirfd, intptr_t newpath, int flags);
-int __syscall_symlinkat(intptr_t target, int newdirfd, intptr_t linkpath);
-int __syscall_readlinkat(int dirfd, intptr_t path, intptr_t buf, size_t bufsize);
-int __syscall_fchmodat2(int dirfd, intptr_t path, int mode, int flags);
-int __syscall_faccessat(int dirfd, intptr_t path, int amode, int flags);
-int __syscall_pselect6(int nfds, intptr_t readfds, intptr_t writefds, intptr_t exceptfds, intptr_t timeout, intptr_t sigmaks);
-int __syscall_utimensat(int dirfd, intptr_t path, intptr_t times, int flags);
+int __syscall_statfs64(const char *path, size_t size, struct statfs *buf);
+int __syscall_fstatfs64(int fd, size_t size, struct statfs *buf);
+int __syscall_fadvise64(int fd, off_t offset, off_t len, int advice);
+int __syscall_openat(int dirfd, const char *path, int flags, ...); // mode is optional
+int __syscall_mkdirat(int dirfd, const char *path, mode_t mode);
+int __syscall_mknodat(int dirfd, const char *path, mode_t mode, dev_t dev);
+int __syscall_fchownat(int dirfd, const char *path, uid_t owner, gid_t group, int flags);
+int __syscall_newfstatat(int dirfd, const char *path, struct stat *buf, int flags);
+int __syscall_unlinkat(int dirfd, const char *path, int flags);
+int __syscall_renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath);
+int __syscall_linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);
+int __syscall_symlinkat(const char *target, int newdirfd, const char *linkpath);
+int __syscall_readlinkat(int dirfd, const char *path, char *buf, size_t bufsize);
+int __syscall_fchmodat2(int dirfd, const char *path, mode_t mode, int flags);
+int __syscall_faccessat(int dirfd, const char *path, int amode, int flags);
+int __syscall_pselect6(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, const /* struct timespec *ts */long ts[2], const void *mask);
+int __syscall_utimensat(int dirfd, const char *path, const struct timespec times[2], int flags);
 int __syscall_fallocate(int fd, int mode, off_t offset, off_t len);
-int __syscall_dup3(int fd, int suggestfd, int flags);
-int __syscall_pipe2(intptr_t fds, int flags);
-int __syscall_recvmmsg(int sockfd, intptr_t msgvec, size_t vlen, int flags, ...);
-int __syscall_prlimit64(int pid, int resource, intptr_t new_limit, intptr_t old_limit);
-int __syscall_sendmmsg(int sockfd, intptr_t msgvec, size_t vlen, int flags, ...);
-int __syscall_socket(int domain, int type, int protocol, int dummy1, int dummy2, int dummy3);
-int __syscall_socketpair(int domain, int type, int protocol, intptr_t fds, int dummy, int dummy2);
-int __syscall_bind(int sockfd, intptr_t addr, size_t alen, int dummy, int dummy2, int dummy3);
-int __syscall_connect(int sockfd, intptr_t addr, size_t len, int dummy, int dummy2, int dummy3);
-int __syscall_listen(int sockfd, int backlock, int dummy1, int dummy2, int dummy3, int dummy4);
-int __syscall_accept4(int sockfd, intptr_t addr, intptr_t addrlen, int flags, int dummy1, int dummy2);
-int __syscall_getsockopt(int sockfd, int level, int optname, intptr_t optval, intptr_t optlen, int dummy);
-int __syscall_setsockopt(int sockfd, int level, int optname, intptr_t optval, size_t optlen, int dummy);
-int __syscall_getsockname(int sockfd, intptr_t addr, intptr_t len, int dummy, int dummy2, int dummy3);
-int __syscall_getpeername(int sockfd, intptr_t addr, intptr_t len, int dummy, int dummy2, int dummy3);
-int __syscall_sendto(int sockfd, intptr_t msg, size_t len, int flags, intptr_t addr, size_t alen);
-int __syscall_sendmsg(int sockfd, intptr_t msg , int flags, intptr_t addr, size_t alen, int dummy);
-int __syscall_recvfrom(int sockfd, intptr_t msg, size_t len, int flags, intptr_t addr, intptr_t alen);
-int __syscall_recvmsg(int sockfd, intptr_t msg, int flags, int dummy, int dummy2, int dummy3);
-int __syscall_shutdown(int sockfd, int how, int dummy, int dummy2, int dummy3, int dummy4);
+int __syscall_dup3(int oldfd, int newfd, int flags);
+int __syscall_pipe2(int pipefd[2], int flags);
+int __syscall_recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags, struct timespec *timeout);
+int __syscall_prlimit64(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit);
+int __syscall_sendmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, unsigned int flags);
+int __syscall_socket(int domain, int type, int protocol, ...);
+int __syscall_socketpair(int domain, int type, int protocol, int fd[2], ...);
+int __syscall_bind(int sockfd, const struct sockaddr *addr, socklen_t len, ...);
+int __syscall_connect(int sockfd, const struct sockaddr *addr, socklen_t len, ...);
+int __syscall_listen(int sockfd, int backlog, ...);
+int __syscall_accept4(int sockfd, struct sockaddr *addr, socklen_t *len, int flags, ...);
+int __syscall_getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen, ...);
+int __syscall_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen, ...);
+int __syscall_getsockname(int sockfd, struct sockaddr *addr, socklen_t *len, ...);
+int __syscall_getpeername(int sockfd, struct sockaddr *addr, socklen_t *len, ...);
+ssize_t __syscall_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen);
+ssize_t __syscall_sendmsg(int sockfd, const struct msghdr *msg, int flags, ...);
+ssize_t __syscall_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen);
+ssize_t __syscall_recvmsg(int sockfd, struct msghdr *msg, int flags, ...);
+int __syscall_shutdown(int sockfd, int how, ...);
 
 #ifdef __cplusplus
 }
diff --git a/system/lib/libc/musl/src/internal/syscall.h b/system/lib/libc/musl/src/internal/syscall.h
index 1a6c4313852d7..5385b71ecb191 100644
--- a/system/lib/libc/musl/src/internal/syscall.h
+++ b/system/lib/libc/musl/src/internal/syscall.h
@@ -19,16 +19,9 @@
 #endif
 
 #ifndef __scc
-#ifdef __EMSCRIPTEN__
-// With emscripten we allow the passing of longer-than-word-sized
-// argument (such as off_t on wasm32) and let binaryen handle splitting
-// them into a pair of i32 arguments.
-#define __scc(X) ((long long) (X))
-#else
 #define __scc(X) ((long) (X))
 #endif
 typedef long syscall_arg_t;
-#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -50,12 +43,12 @@ hidden long __syscall_ret(unsigned long),
 #else // __EMSCRIPTEN__
 #define __syscall_emscripten(n, ...) n(__VA_ARGS__)
 #define __syscall_emscripten0(n) __syscall_emscripten(n)
-#define __syscall_emscripten1(n,a) __syscall_emscripten(n,__scc(a))
-#define __syscall_emscripten2(n,a,b) __syscall_emscripten(n,__scc(a),__scc(b))
-#define __syscall_emscripten3(n,a,b,c) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c))
-#define __syscall_emscripten4(n,a,b,c,d) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d))
-#define __syscall_emscripten5(n,a,b,c,d,e) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e))
-#define __syscall_emscripten6(n,a,b,c,d,e,f) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f))
+#define __syscall_emscripten1(n,a) __syscall_emscripten(n,a)
+#define __syscall_emscripten2(n,a,b) __syscall_emscripten(n,a,b)
+#define __syscall_emscripten3(n,a,b,c) __syscall_emscripten(n,a,b,c)
+#define __syscall_emscripten4(n,a,b,c,d) __syscall_emscripten(n,a,b,c,d)
+#define __syscall_emscripten5(n,a,b,c,d,e) __syscall_emscripten(n,a,b,c,d,e)
+#define __syscall_emscripten6(n,a,b,c,d,e,f) __syscall_emscripten(n,a,b,c,d,e,f)
 #endif // __EMSCRIPTEN__
 
 #define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
@@ -421,10 +414,10 @@ hidden long __syscall_ret(unsigned long),
 #define __sys_open_cp3(x,pn,fl,mo) __syscall_cp4(SYS_openat, AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
 #endif
 #else // __EMSCRIPTEN__
-#define __sys_open2(x,pn,fl) __syscall_openat(__scc(AT_FDCWD), __scc(pn), __scc((fl)|O_LARGEFILE))
-#define __sys_open3(x,pn,fl,mo) __syscall_openat(__scc(AT_FDCWD), __scc(pn), __scc((fl)|O_LARGEFILE), __scc(mo))
-#define __sys_open_cp2(x,pn,fl) __syscall_openat(__scc(AT_FDCWD), __scc(pn), __scc((fl)|O_LARGEFILE))
-#define __sys_open_cp3(x,pn,fl,mo) __syscall_openat(__scc(AT_FDCWD), __scc(pn), __scc((fl)|O_LARGEFILE), __scc(mo))
+#define __sys_open2(x,pn,fl) __syscall_openat(AT_FDCWD, pn, (fl)|O_LARGEFILE)
+#define __sys_open3(x,pn,fl,mo) __syscall_openat(AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
+#define __sys_open_cp2(x,pn,fl) __syscall_openat(AT_FDCWD, pn, (fl)|O_LARGEFILE)
+#define __sys_open_cp3(x,pn,fl,mo) __syscall_openat(AT_FDCWD, pn, (fl)|O_LARGEFILE, mo)
 #endif
 
 #define __sys_open(...) __SYSCALL_DISP(__sys_open,,__VA_ARGS__)
diff --git a/system/lib/standalone/standalone.c b/system/lib/standalone/standalone.c
index fdca8d949fa3f..1314697ed19d6 100644
--- a/system/lib/standalone/standalone.c
+++ b/system/lib/standalone/standalone.c
@@ -62,7 +62,7 @@ weak int _mmap_js(size_t length,
 }
 
 weak int _munmap_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset) {
+  void *addr, size_t length, int prot, int flags, int fd, off_t offset) {
   return -ENOSYS;
 }
 
@@ -70,14 +70,14 @@ weak int _munmap_js(
 // corner case error checking; everything else is not permitted.
 // TODO: full file support for WASI, or an option for it
 // open()
-weak int __syscall_openat(int dirfd, intptr_t path, int flags, ...) {
-  if (!strcmp((const char*)path, "/dev/stdin")) {
+weak int __syscall_openat(int dirfd, const char *path, int flags, ...) {
+  if (!strcmp(path, "/dev/stdin")) {
     return STDIN_FILENO;
   }
-  if (!strcmp((const char*)path, "/dev/stdout")) {
+  if (!strcmp(path, "/dev/stdout")) {
     return STDOUT_FILENO;
   }
-  if (!strcmp((const char*)path, "/dev/stderr")) {
+  if (!strcmp(path, "/dev/stderr")) {
     return STDERR_FILENO;
   }
   return -EPERM;
@@ -91,11 +91,11 @@ weak int __syscall_fcntl64(int fd, int cmd, ...) {
   return -ENOSYS;
 }
 
-weak int __syscall_fstat64(int fd, intptr_t buf) {
+weak int __syscall_fstat64(int fd, struct stat *buf) {
   return -ENOSYS;
 }
 
-weak int __syscall_stat64(intptr_t path, intptr_t buf) {
+weak int __syscall_stat64(const char *path, struct stat *buf) {
   return -ENOSYS;
 }
 
@@ -103,15 +103,15 @@ weak int __syscall_dup(int fd) {
   return -ENOSYS;
 }
 
-weak int __syscall_mkdirat(int dirfd, intptr_t path, int mode) {
+weak int __syscall_mkdirat(int dirfd, const char *path, mode_t mode) {
   return -ENOSYS;
 }
 
-weak int __syscall_newfstatat(int dirfd, intptr_t path, intptr_t buf, int flags) {
+weak int __syscall_newfstatat(int dirfd, const char *path, struct stat *buf, int flags) {
   return -ENOSYS;
 }
 
-weak int __syscall_lstat64(intptr_t path, intptr_t buf) {
+weak int __syscall_lstat64(const char *path, struct stat *buf) {
   return -ENOSYS;
 }
 
diff --git a/system/lib/wasmfs/js_api.cpp b/system/lib/wasmfs/js_api.cpp
index dba5fdb6dd93d..c5dca36a98006 100644
--- a/system/lib/wasmfs/js_api.cpp
+++ b/system/lib/wasmfs/js_api.cpp
@@ -114,36 +114,35 @@ int _wasmfs_write_file(const char* pathname, char* data, size_t data_size) {
   return data_size;
 }
 
-int _wasmfs_mkdir(const char* path, int mode) {
-  return __syscall_mkdirat(AT_FDCWD, (intptr_t)path, mode);
+int _wasmfs_mkdir(const char* path, mode_t mode) {
+  return __syscall_mkdirat(AT_FDCWD, path, mode);
 }
 
 int _wasmfs_rmdir(const char* path) {
-  return __syscall_unlinkat(AT_FDCWD, (intptr_t)path, AT_REMOVEDIR);
+  return __syscall_unlinkat(AT_FDCWD, path, AT_REMOVEDIR);
 }
 
 int _wasmfs_open(const char* path, int flags, mode_t mode) {
-  return __syscall_openat(AT_FDCWD, (intptr_t)path, flags, mode);
+  return __syscall_openat(AT_FDCWD, path, flags, mode);
 }
 
 int _wasmfs_mknod(const char* path, mode_t mode, dev_t dev) {
-  return __syscall_mknodat(AT_FDCWD, (intptr_t)path, mode, dev);
+  return __syscall_mknodat(AT_FDCWD, path, mode, dev);
 }
 
 int _wasmfs_unlink(const char* path) {
-  return __syscall_unlinkat(AT_FDCWD, (intptr_t)path, 0);
+  return __syscall_unlinkat(AT_FDCWD, path, 0);
 }
 
-int _wasmfs_chdir(const char* path) { return __syscall_chdir((intptr_t)path); }
+int _wasmfs_chdir(const char* path) { return __syscall_chdir(path); }
 
 int _wasmfs_symlink(const char* old_path, const char* new_path) {
-  return __syscall_symlinkat((intptr_t)old_path, AT_FDCWD, (intptr_t)new_path);
+  return __syscall_symlinkat(old_path, AT_FDCWD, new_path);
 }
 
 int _wasmfs_readlink(const char* path, char** out_ptr) {
   static thread_local char* readBuf = (char*)malloc(PATH_MAX);
-  int bytes =
-    __syscall_readlinkat(AT_FDCWD, (intptr_t)path, (intptr_t)readBuf, PATH_MAX);
+  int bytes = __syscall_readlinkat(AT_FDCWD, path, readBuf, PATH_MAX);
   if (bytes < 0) {
     return bytes;
   }
@@ -179,14 +178,13 @@ int _wasmfs_pwrite(int fd, void* buf, size_t count, off_t offset) {
 }
 
 int _wasmfs_chmod(const char* path, mode_t mode) {
-  return __syscall_chmod((intptr_t)path, mode);
+  return __syscall_chmod(path, mode);
 }
 
 int _wasmfs_fchmod(int fd, mode_t mode) { return __syscall_fchmod(fd, mode); }
 
 int _wasmfs_lchmod(const char* path, mode_t mode) {
-  return __syscall_fchmodat2(
-    AT_FDCWD, (intptr_t)path, mode, AT_SYMLINK_NOFOLLOW);
+  return __syscall_fchmodat2(AT_FDCWD, path, mode, AT_SYMLINK_NOFOLLOW);
 }
 
 int _wasmfs_llseek(int fd, off_t offset, int whence) {
@@ -199,8 +197,7 @@ int _wasmfs_llseek(int fd, off_t offset, int whence) {
 }
 
 int _wasmfs_rename(const char* oldpath, const char* newpath) {
-  return __syscall_renameat(
-    AT_FDCWD, (intptr_t)oldpath, AT_FDCWD, (intptr_t)newpath);
+  return __syscall_renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath);
 }
 
 int _wasmfs_read(int fd, void* buf, size_t count) {
@@ -230,7 +227,7 @@ int _wasmfs_pread(int fd, void* buf, size_t count, off_t offset) {
 }
 
 int _wasmfs_truncate(const char* path, off_t length) {
-  return __syscall_truncate64((intptr_t)path, length);
+  return __syscall_truncate64(path, length);
 }
 
 int _wasmfs_ftruncate(int fd, off_t length) {
@@ -244,11 +241,11 @@ void* _wasmfs_mmap(size_t length, int prot, int flags, int fd, off_t offset) {
 }
 
 int _wasmfs_msync(void* addr, size_t length, int flags) {
-  return __syscall_msync((intptr_t)addr, length, flags);
+  return __syscall_msync(addr, length, flags);
 }
 
 int _wasmfs_munmap(void* addr, size_t length) {
-  return __syscall_munmap((intptr_t)addr, length);
+  return __syscall_munmap(addr, length);
 }
 
 int _wasmfs_utime(const char* path, double atime_ms, double mtime_ms) {
@@ -258,22 +255,22 @@ int _wasmfs_utime(const char* path, double atime_ms, double mtime_ms) {
   times[1].tv_sec = (long)mtime_ms / 1000;
   times[1].tv_nsec = ((long)mtime_ms % 1000) * 1000000;
 
-  return __syscall_utimensat(AT_FDCWD, (intptr_t)path, (intptr_t)times, 0);
+  return __syscall_utimensat(AT_FDCWD, path, times, 0);
 }
 
 int _wasmfs_stat(const char* path, struct stat* statBuf) {
-  return __syscall_stat64((intptr_t)path, (intptr_t)statBuf);
+  return __syscall_stat64(path, statBuf);
 }
 
 int _wasmfs_lstat(const char* path, struct stat* statBuf) {
-  return __syscall_lstat64((intptr_t)path, (intptr_t)statBuf);
+  return __syscall_lstat64(path, statBuf);
 }
 
 // The legacy JS API requires a mountpoint to already exist, so  WasmFS will
 // attempt to remove the target directory if it exists before replacing it with
 // a mounted directory.
 int _wasmfs_mount(const char* path, ::backend_t created_backend) {
-  int err = __syscall_rmdir((intptr_t)path);
+  int err = __syscall_rmdir(path);
 
   // The legacy JS API mount requires the directory to already exist, but we
   // will also allow it to be missing.
diff --git a/system/lib/wasmfs/syscalls.cpp b/system/lib/wasmfs/syscalls.cpp
index 64932128d19ad..c0e6c7024c5c9 100644
--- a/system/lib/wasmfs/syscalls.cpp
+++ b/system/lib/wasmfs/syscalls.cpp
@@ -347,18 +347,21 @@ backend_t wasmfs_get_backend_by_path(const char* path) {
 static timespec ms_to_timespec(double ms) {
   long long seconds = ms / 1000;
   timespec ts;
-  ts.tv_sec = seconds; // seconds
+  ts.tv_sec = seconds;                                // seconds
   ts.tv_nsec = (ms - (seconds * 1000)) * 1000 * 1000; // nanoseconds
   return ts;
 }
 
-int __syscall_newfstatat(int dirfd, intptr_t path, intptr_t buf, int flags) {
+int __syscall_newfstatat(int dirfd,
+                         const char* path,
+                         struct stat* buf,
+                         int flags) {
   // Only accept valid flags.
   if (flags & ~(AT_EMPTY_PATH | AT_NO_AUTOMOUNT | AT_SYMLINK_NOFOLLOW)) {
     // TODO: Test this case.
     return -EINVAL;
   }
-  auto parsed = path::getFileAt(dirfd, (char*)path, flags);
+  auto parsed = path::getFileAt(dirfd, path, flags);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -366,48 +369,47 @@ int __syscall_newfstatat(int dirfd, intptr_t path, intptr_t buf, int flags) {
 
   // Extract the information from the file.
   auto lockedFile = file->locked();
-  auto buffer = (struct stat*)buf;
 
   off_t size = lockedFile.getSize();
   if (size < 0) {
     return size;
   }
-  buffer->st_size = size;
+  buf->st_size = size;
 
   // ATTN: hard-coded constant values are copied from the existing JS file
   // system. Specific values were chosen to match existing library_fs.js
   // values.
   // ID of device containing file: Hardcode 1 for now, no meaning at the
   // moment for Emscripten.
-  buffer->st_dev = 1;
-  buffer->st_mode = lockedFile.getMode();
-  buffer->st_ino = file->getIno();
+  buf->st_dev = 1;
+  buf->st_mode = lockedFile.getMode();
+  buf->st_ino = file->getIno();
   // The number of hard links is 1 since they are unsupported.
-  buffer->st_nlink = 1;
-  buffer->st_uid = 0;
-  buffer->st_gid = 0;
+  buf->st_nlink = 1;
+  buf->st_uid = 0;
+  buf->st_gid = 0;
   // Device ID (if special file) No meaning right now for Emscripten.
-  buffer->st_rdev = 0;
+  buf->st_rdev = 0;
   // The syscall docs state this is hardcoded to # of 512 byte blocks.
-  buffer->st_blocks = (buffer->st_size + 511) / 512;
+  buf->st_blocks = (buf->st_size + 511) / 512;
   // Specifies the preferred blocksize for efficient disk I/O.
-  buffer->st_blksize = 4096;
-  buffer->st_atim = ms_to_timespec(lockedFile.getATime());
-  buffer->st_mtim = ms_to_timespec(lockedFile.getMTime());
-  buffer->st_ctim = ms_to_timespec(lockedFile.getCTime());
+  buf->st_blksize = 4096;
+  buf->st_atim = ms_to_timespec(lockedFile.getATime());
+  buf->st_mtim = ms_to_timespec(lockedFile.getMTime());
+  buf->st_ctim = ms_to_timespec(lockedFile.getCTime());
   return __WASI_ERRNO_SUCCESS;
 }
 
-int __syscall_stat64(intptr_t path, intptr_t buf) {
+int __syscall_stat64(const char* path, struct stat* buf) {
   return __syscall_newfstatat(AT_FDCWD, path, buf, 0);
 }
 
-int __syscall_lstat64(intptr_t path, intptr_t buf) {
+int __syscall_lstat64(const char* path, struct stat* buf) {
   return __syscall_newfstatat(AT_FDCWD, path, buf, AT_SYMLINK_NOFOLLOW);
 }
 
-int __syscall_fstat64(int fd, intptr_t buf) {
-  return __syscall_newfstatat(fd, (intptr_t) "", buf, AT_EMPTY_PATH);
+int __syscall_fstat64(int fd, struct stat* buf) {
+  return __syscall_newfstatat(fd, "", buf, AT_EMPTY_PATH);
 }
 
 // When calling doOpen(), we may request an FD be returned, or we may not need
@@ -564,25 +566,24 @@ static __wasi_fd_t doOpen(path::ParsedParent parsed,
 
 // This function is exposed to users and allows users to create a file in a
 // specific backend. An fd to an open file is returned.
-int wasmfs_create_file(char* pathname, mode_t mode, backend_t backend) {
+int wasmfs_create_file(const char* pathname, mode_t mode, backend_t backend) {
   static_assert(std::is_same_v<decltype(doOpen(0, 0, 0, 0)), unsigned int>,
                 "unexpected conversion from result of doOpen to int");
-  return doOpen(
-    path::parseParent((char*)pathname), O_CREAT | O_EXCL, mode, backend);
+  return doOpen(path::parseParent(pathname), O_CREAT | O_EXCL, mode, backend);
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_openat(int dirfd, intptr_t path, int flags, ...) {
+int __syscall_openat(int dirfd, const char* path, int flags, ...) {
   mode_t mode = 0;
   va_list v1;
   va_start(v1, flags);
   mode = va_arg(v1, int);
   va_end(v1);
 
-  return doOpen(path::parseParent((char*)path, dirfd), flags, mode);
+  return doOpen(path::parseParent(path, dirfd), flags, mode);
 }
 
-int __syscall_mknodat(int dirfd, intptr_t path, int mode, int dev) {
+int __syscall_mknodat(int dirfd, const char* path, mode_t mode, dev_t dev) {
   assert(dev == 0); // TODO: support special devices
   if (mode & S_IFDIR) {
     return -EINVAL;
@@ -590,15 +591,16 @@ int __syscall_mknodat(int dirfd, intptr_t path, int mode, int dev) {
   if (mode & S_IFIFO) {
     return -EPERM;
   }
-  return doOpen(path::parseParent((char*)path, dirfd),
+  return doOpen(path::parseParent(path, dirfd),
                 O_CREAT | O_EXCL,
                 mode,
                 NullBackend,
                 OpenReturnMode::Nothing);
 }
 
-static int
-doMkdir(path::ParsedParent parsed, int mode, backend_t backend = NullBackend) {
+static int doMkdir(path::ParsedParent parsed,
+                   mode_t mode,
+                   backend_t backend = NullBackend) {
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -655,15 +657,15 @@ doMkdir(path::ParsedParent parsed, int mode, backend_t backend = NullBackend) {
 
 // This function is exposed to users and allows users to specify a particular
 // backend that a directory should be created within.
-int wasmfs_create_directory(char* path, int mode, backend_t backend) {
+int wasmfs_create_directory(char* path, mode_t mode, backend_t backend) {
   static_assert(std::is_same_v<decltype(doMkdir(0, 0, 0)), int>,
                 "unexpected conversion from result of doMkdir to int");
   return doMkdir(path::parseParent(path), mode, backend);
 }
 
 // TODO: Test this.
-int __syscall_mkdirat(int dirfd, intptr_t path, int mode) {
-  return doMkdir(path::parseParent((char*)path, dirfd), mode);
+int __syscall_mkdirat(int dirfd, const char* path, mode_t mode) {
+  return doMkdir(path::parseParent(path, dirfd), mode);
 }
 
 __wasi_errno_t __wasi_fd_seek(__wasi_fd_t fd,
@@ -720,8 +722,8 @@ static int doChdir(std::shared_ptr<File>& file) {
   return 0;
 }
 
-int __syscall_chdir(intptr_t path) {
-  auto parsed = path::parseFile((char*)path);
+int __syscall_chdir(const char* path) {
+  auto parsed = path::parseFile(path);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -736,7 +738,7 @@ int __syscall_fchdir(int fd) {
   return doChdir(openFile->locked().getFile());
 }
 
-int __syscall_getcwd(intptr_t buf, size_t size) {
+int __syscall_getcwd(char* buf, size_t size) {
   // Check if buf points to a bad address.
   if (!buf && size > 0) {
     return -EFAULT;
@@ -778,7 +780,7 @@ int __syscall_getcwd(intptr_t buf, size_t size) {
   }
 
   // Return value is a null-terminated c string.
-  strcpy((char*)buf, result.c_str());
+  strcpy(buf, result.c_str());
 
   return len;
 }
@@ -802,7 +804,7 @@ __wasi_errno_t __wasi_fd_fdstat_get(__wasi_fd_t fd, __wasi_fdstat_t* stat) {
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_unlinkat(int dirfd, intptr_t path, int flags) {
+int __syscall_unlinkat(int dirfd, const char* path, int flags) {
   if (flags & ~AT_REMOVEDIR) {
     // TODO: Test this case.
     return -EINVAL;
@@ -811,7 +813,7 @@ int __syscall_unlinkat(int dirfd, intptr_t path, int flags) {
   // this case from the case of `parseParent` returning (root, '.') when parsing
   // "/", so we need to find the invalid "/." manually.
   if (flags == AT_REMOVEDIR) {
-    std::string_view p((char*)path);
+    std::string_view p(path);
     // Ignore trailing '/'.
     while (!p.empty() && p.back() == '/') {
       p.remove_suffix(1);
@@ -820,7 +822,7 @@ int __syscall_unlinkat(int dirfd, intptr_t path, int flags) {
       return -EINVAL;
     }
   }
-  auto parsed = path::parseParent((char*)path, dirfd);
+  auto parsed = path::parseParent(path, dirfd);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -861,7 +863,7 @@ int __syscall_unlinkat(int dirfd, intptr_t path, int flags) {
   return lockedParent.removeChild(childName);
 }
 
-int __syscall_rmdir(intptr_t path) {
+int __syscall_rmdir(const char* path) {
   return __syscall_unlinkat(AT_FDCWD, path, AT_REMOVEDIR);
 }
 
@@ -898,7 +900,7 @@ int wasmfs_unmount(const char* path) {
   return lockedParent.removeChild(childName);
 }
 
-int __syscall_getdents64(int fd, intptr_t dirp, size_t count) {
+int __syscall_getdents64(int fd, void* dirp, size_t count) {
   dirent* result = (dirent*)dirp;
 
   // Check if the result buffer is too small.
@@ -967,9 +969,9 @@ int __syscall_getdents64(int fd, intptr_t dirp, size_t count) {
 
 // TODO: Test this with non-AT_FDCWD values.
 int __syscall_renameat(int olddirfd,
-                       intptr_t oldpath,
+                       const char* oldpath,
                        int newdirfd,
-                       intptr_t newpath) {
+                       const char* newpath) {
   // Rename is the only syscall that needs to (or is allowed to) acquire locks
   // on two directories at once. It requires locks on both the old and new
   // parent directories to ensure that the moved file can be atomically removed
@@ -982,7 +984,7 @@ int __syscall_renameat(int olddirfd,
   std::lock_guard<std::mutex> renameLock(renameMutex);
 
   // Get the old directory.
-  auto parsedOld = path::parseParent((char*)oldpath, olddirfd);
+  auto parsedOld = path::parseParent(oldpath, olddirfd);
   if (auto err = parsedOld.getError()) {
     return err;
   }
@@ -990,7 +992,7 @@ int __syscall_renameat(int olddirfd,
   std::string oldFileName(oldFileNameView);
 
   // Get the new directory.
-  auto parsedNew = path::parseParent((char*)newpath, newdirfd);
+  auto parsedNew = path::parseParent(newpath, newdirfd);
   if (auto err = parsedNew.getError()) {
     return err;
   }
@@ -1071,8 +1073,10 @@ int __syscall_renameat(int olddirfd,
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_symlinkat(intptr_t target, int newdirfd, intptr_t linkpath) {
-  auto parsed = path::parseParent((char*)linkpath, newdirfd);
+int __syscall_symlinkat(const char* target,
+                        int newdirfd,
+                        const char* linkpath) {
+  auto parsed = path::parseParent(linkpath, newdirfd);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1085,7 +1089,7 @@ int __syscall_symlinkat(intptr_t target, int newdirfd, intptr_t linkpath) {
   if (lockedParent.getChild(childName)) {
     return -EEXIST;
   }
-  if (!lockedParent.insertSymlink(childName, (char*)target)) {
+  if (!lockedParent.insertSymlink(childName, target)) {
     return -EPERM;
   }
   return 0;
@@ -1093,11 +1097,11 @@ int __syscall_symlinkat(intptr_t target, int newdirfd, intptr_t linkpath) {
 
 // TODO: Test this with non-AT_FDCWD values.
 int __syscall_readlinkat(int dirfd,
-                         intptr_t path,
-                         intptr_t buf,
+                         const char* path,
+                         char* buf,
                          size_t bufsize) {
   // TODO: Handle empty paths.
-  auto parsed = path::parseFile((char*)path, dirfd, path::NoFollowLinks);
+  auto parsed = path::parseFile(path, dirfd, path::NoFollowLinks);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1107,7 +1111,7 @@ int __syscall_readlinkat(int dirfd,
   }
   const auto& target = link->getTarget();
   auto bytes = std::min((size_t)bufsize, target.size());
-  memcpy((char*)buf, target.c_str(), bytes);
+  memcpy(buf, target.c_str(), bytes);
   return bytes;
 }
 
@@ -1122,9 +1126,10 @@ static double timespec_to_ms(timespec ts) {
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_utimensat(int dirFD, intptr_t path_, intptr_t times_, int flags) {
-  const char* path = (const char*)path_;
-  const struct timespec* times = (const struct timespec*)times_;
+int __syscall_utimensat(int dirfd,
+                        const char* path,
+                        const struct timespec times[2],
+                        int flags) {
   if (flags & ~AT_SYMLINK_NOFOLLOW) {
     // TODO: Test this case.
     return -EINVAL;
@@ -1137,7 +1142,7 @@ int __syscall_utimensat(int dirFD, intptr_t path_, intptr_t times_, int flags) {
   // https://man7.org/linux/man-pages/man2/utimensat.2.html
   //
   // TODO: Handle AT_SYMLINK_NOFOLLOW once we traverse symlinks correctly.
-  auto parsed = path::getFileAt(dirFD, path, flags | AT_EMPTY_PATH);
+  auto parsed = path::getFileAt(dirfd, path, flags | AT_EMPTY_PATH);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1165,12 +1170,12 @@ int __syscall_utimensat(int dirFD, intptr_t path_, intptr_t times_, int flags) {
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_fchmodat2(int dirfd, intptr_t path, int mode, int flags) {
+int __syscall_fchmodat2(int dirfd, const char* path, mode_t mode, int flags) {
   if (flags & ~AT_SYMLINK_NOFOLLOW) {
     // TODO: Test this case.
     return -EINVAL;
   }
-  auto parsed = path::getFileAt(dirfd, (char*)path, flags);
+  auto parsed = path::getFileAt(dirfd, path, flags);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1181,11 +1186,11 @@ int __syscall_fchmodat2(int dirfd, intptr_t path, int mode, int flags) {
   return 0;
 }
 
-int __syscall_chmod(intptr_t path, int mode) {
+int __syscall_chmod(const char* path, mode_t mode) {
   return __syscall_fchmodat2(AT_FDCWD, path, mode, 0);
 }
 
-int __syscall_fchmod(int fd, int mode) {
+int __syscall_fchmod(int fd, mode_t mode) {
   auto openFile = wasmFS.getFileTable().locked().getEntry(fd);
   if (!openFile) {
     return -EBADF;
@@ -1197,13 +1202,13 @@ int __syscall_fchmod(int fd, int mode) {
 }
 
 int __syscall_fchownat(
-  int dirfd, intptr_t path, int owner, int group, int flags) {
+  int dirfd, const char* path, uid_t owner, gid_t group, int flags) {
   // Only accept valid flags.
   if (flags & ~(AT_EMPTY_PATH | AT_SYMLINK_NOFOLLOW)) {
     // TODO: Test this case.
     return -EINVAL;
   }
-  auto parsed = path::getFileAt(dirfd, (char*)path, flags);
+  auto parsed = path::getFileAt(dirfd, path, flags);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1213,12 +1218,12 @@ int __syscall_fchownat(
   return 0;
 }
 
-int __syscall_fchown32(int fd, int owner, int group) {
-  return __syscall_fchownat(fd, (intptr_t) "", owner, group, AT_EMPTY_PATH);
+int __syscall_fchown32(int fd, uid_t owner, gid_t group) {
+  return __syscall_fchownat(fd, "", owner, group, AT_EMPTY_PATH);
 }
 
 // TODO: Test this with non-AT_FDCWD values.
-int __syscall_faccessat(int dirfd, intptr_t path, int amode, int flags) {
+int __syscall_faccessat(int dirfd, const char* path, int amode, int flags) {
   // The input must be F_OK (check for existence) or a combination of [RWX]_OK
   // flags.
   if (amode != F_OK && (amode & ~(R_OK | W_OK | X_OK))) {
@@ -1230,7 +1235,7 @@ int __syscall_faccessat(int dirfd, intptr_t path, int amode, int flags) {
   }
 
   // TODO: Handle AT_SYMLINK_NOFOLLOW once we traverse symlinks correctly.
-  auto parsed = path::parseFile((char*)path, dirfd);
+  auto parsed = path::parseFile(path, dirfd);
   if (auto err = parsed.getError()) {
     return err;
   }
@@ -1272,12 +1277,12 @@ static int doTruncate(std::shared_ptr<File>& file, off_t size) {
   return ret;
 }
 
-int __syscall_truncate64(intptr_t path, off_t size) {
-  auto parsed = path::parseFile((char*)path);
+int __syscall_truncate64(const char* path, off_t length) {
+  auto parsed = path::parseFile(path);
   if (auto err = parsed.getError()) {
     return err;
   }
-  return doTruncate(parsed.getFile(), size);
+  return doTruncate(parsed.getFile(), length);
 }
 
 int __syscall_ftruncate64(int fd, off_t size) {
@@ -1331,7 +1336,7 @@ int __syscall_ioctl(int fd, int request, ...) {
   }
 }
 
-int __syscall_pipe(intptr_t fd) {
+int __syscall_pipe(int fd[2]) {
   auto* fds = (__wasi_fd_t*)fd;
 
   // Make a pipe: Two PipeFiles that share a single data source between them, so
@@ -1353,9 +1358,7 @@ int __syscall_pipe(intptr_t fd) {
   return 0;
 }
 
-// int poll(struct pollfd* fds, nfds_t nfds, int timeout);
-int __syscall_poll(intptr_t fds_, int nfds, int timeout) {
-  struct pollfd* fds = (struct pollfd*)fds_;
+int __syscall_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
   auto fileTable = wasmFS.getFileTable().locked();
 
   // Process the list of FDs and compute their revents masks. Count the number
@@ -1555,20 +1558,20 @@ doStatFS(std::shared_ptr<File>& file, size_t size, struct statfs* buf) {
   return 0;
 }
 
-int __syscall_statfs64(intptr_t path, size_t size, intptr_t buf) {
-  auto parsed = path::parseFile((char*)path);
+int __syscall_statfs64(const char* path, size_t size, struct statfs* buf) {
+  auto parsed = path::parseFile(path);
   if (auto err = parsed.getError()) {
     return err;
   }
-  return doStatFS(parsed.getFile(), size, (struct statfs*)buf);
+  return doStatFS(parsed.getFile(), size, buf);
 }
 
-int __syscall_fstatfs64(int fd, size_t size, intptr_t buf) {
+int __syscall_fstatfs64(int fd, size_t size, struct statfs* buf) {
   auto openFile = wasmFS.getFileTable().locked().getEntry(fd);
   if (!openFile) {
     return -EBADF;
   }
-  return doStatFS(openFile->locked().getFile(), size, (struct statfs*)buf);
+  return doStatFS(openFile->locked().getFile(), size, buf);
 }
 
 int _mmap_js(size_t length,
@@ -1666,7 +1669,7 @@ int _mmap_js(size_t length,
 }
 
 int _msync_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset) {
+  void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
   // TODO: This is not correct! Mappings should be associated with files, not
   // fds. Only need to sync if shared and writes are allowed.
   int mapType = flags & MAP_TYPE;
@@ -1682,7 +1685,7 @@ int _msync_js(
 }
 
 int _munmap_js(
-  intptr_t addr, size_t length, int prot, int flags, int fd, off_t offset) {
+  void* addr, size_t length, int prot, int flags, int fd, off_t offset) {
   // TODO: This is not correct! Mappings should be associated with files, not
   // fds.
   // TODO: Syncing should probably be handled in __syscall_munmap instead.
@@ -1691,88 +1694,87 @@ int _munmap_js(
 
 // Stubs (at least for now)
 
-int __syscall_accept4(int sockfd,
-                      intptr_t addr,
-                      intptr_t addrlen,
-                      int flags,
-                      int dummy1,
-                      int dummy2) {
+int __syscall_accept4(
+  int sockfd, struct sockaddr* addr, socklen_t* len, int flags, ...) {
   return -ENOSYS;
 }
 
-int __syscall_bind(
-  int sockfd, intptr_t addr, size_t alen, int dummy, int dummy2, int dummy3) {
+int __syscall_bind(int sockfd,
+                   const struct sockaddr* addr,
+                   socklen_t len,
+                   ...) {
   return -ENOSYS;
 }
 
-int __syscall_connect(
-  int sockfd, intptr_t addr, size_t len, int dummy, int dummy2, int dummy3) {
+int __syscall_connect(int sockfd,
+                      const struct sockaddr* addr,
+                      socklen_t len,
+                      ...) {
   return -ENOSYS;
 }
 
-int __syscall_socket(
-  int domain, int type, int protocol, int dummy1, int dummy2, int dummy3) {
+int __syscall_socket(int domain, int type, int protocol, ...) {
   return -ENOSYS;
 }
 
-int __syscall_listen(
-  int sockfd, int backlock, int dummy1, int dummy2, int dummy3, int dummy4) {
-  return -ENOSYS;
-}
+int __syscall_listen(int sockfd, int backlog, ...) { return -ENOSYS; }
 
-int __syscall_getsockopt(int sockfd,
-                         int level,
-                         int optname,
-                         intptr_t optval,
-                         intptr_t optlen,
-                         int dummy) {
+int __syscall_getsockopt(
+  int sockfd, int level, int optname, void* optval, socklen_t* optlen, ...) {
   return -ENOSYS;
 }
 
-int __syscall_getsockname(
-  int sockfd, intptr_t addr, intptr_t len, int dummy, int dummy2, int dummy3) {
+int __syscall_getsockname(int sockfd,
+                          struct sockaddr* addr,
+                          socklen_t* len,
+                          ...) {
   return -ENOSYS;
 }
 
-int __syscall_getpeername(
-  int sockfd, intptr_t addr, intptr_t len, int dummy, int dummy2, int dummy3) {
+int __syscall_getpeername(int sockfd,
+                          struct sockaddr* addr,
+                          socklen_t* len,
+                          ...) {
   return -ENOSYS;
 }
 
-int __syscall_sendto(
-  int sockfd, intptr_t msg, size_t len, int flags, intptr_t addr, size_t alen) {
+ssize_t __syscall_sendto(int sockfd,
+                         const void* buf,
+                         size_t len,
+                         int flags,
+                         const struct sockaddr* addr,
+                         socklen_t alen) {
   return -ENOSYS;
 }
 
-int __syscall_sendmsg(
-  int sockfd, intptr_t msg, int flags, intptr_t addr, size_t alen, int dummy) {
+ssize_t
+__syscall_sendmsg(int sockfd, const struct msghdr* msg, int flags, ...) {
   return -ENOSYS;
 }
 
-int __syscall_recvfrom(int sockfd,
-                       intptr_t msg,
-                       size_t len,
-                       int flags,
-                       intptr_t addr,
-                       intptr_t alen) {
+ssize_t __syscall_recvfrom(int sockfd,
+                           void* buf,
+                           size_t len,
+                           int flags,
+                           struct sockaddr* addr,
+                           socklen_t* alen) {
   return -ENOSYS;
 }
 
-int __syscall_recvmsg(
-  int sockfd, intptr_t msg, int flags, int dummy, int dummy2, int dummy3) {
+ssize_t __syscall_recvmsg(int sockfd, struct msghdr* msg, int flags, ...) {
   return -ENOSYS;
 }
 
-int __syscall_fadvise64(int fd, off_t offset, off_t length, int advice) {
+int __syscall_fadvise64(int fd, off_t offset, off_t len, int advice) {
   // Advice is currently ignored. TODO some backends might use it
   return 0;
 }
 
 int __syscall__newselect(int nfds,
-                         intptr_t readfds_,
-                         intptr_t writefds_,
-                         intptr_t exceptfds_,
-                         intptr_t timeout_) {
+                         fd_set* readfds_,
+                         fd_set* writefds_,
+                         fd_set* exceptfds_,
+                         long _timeout[2]) {
   // TODO: Implement this syscall. For now, we return an error code,
   //       specifically ENOMEM which is valid per the docs:
   //          ENOMEM Unable to allocate memory for internal tables