Simpify passing of timeout to select() syscall. NFC (#25968)

Rather than using a pointer to memory, simply pass the number of
milliseconds to block for, using the same convensions poll():

```
-1: Block forever
 0: No blocking
>0: Block for up to N milliseconds.
```

This is already the interface used by the inner `stream.stream_ops.poll`
call so this saves on conversion as well as reading from memory.

Author: sbc100

src/lib/libsigs.js

@@ -229,7 +229,7 @@ sigs = {
   __handle_stack_overflow__sig: 'vp',
   __pthread_create_js__sig: 'ipppp',
   __resumeException__sig: 'vp',
-  __syscall__newselect__sig: 'iipppp',
+  __syscall__newselect__sig: 'iipppj',
   __syscall_accept4__sig: 'iippiii',
   __syscall_bind__sig: 'iippiii',
   __syscall_chdir__sig: 'ip',

src/lib/libsyscall.js

@@ -542,7 +542,8 @@ var SyscallsLibrary = {
     FS.chdir(stream.path);
     return 0;
   },
-  __syscall__newselect: (nfds, readfds, writefds, exceptfds, timeout) => {
+  __syscall__newselect__i53abi: true,
+  __syscall__newselect: (nfds, readfds, writefds, exceptfds, timeoutInMillis) => {
     // readfds are supported,
     // writefds checks socket open status
     // exceptfds are supported, although on web, such exceptional conditions never arise in web sockets
@@ -584,18 +585,11 @@ var SyscallsLibrary = {
       var flags = SYSCALLS.DEFAULT_POLLMASK;
 
       if (stream.stream_ops.poll) {
-        var timeoutInMillis = -1;
-        if (timeout) {
-          // select(2) is declared to accept "struct timeval { time_t tv_sec; suseconds_t tv_usec; }".
-          // However, musl passes the two values to the syscall as an array of long values.
-          // Note that sizeof(time_t) != sizeof(long) in wasm32. The former is 8, while the latter is 4.
-          // This means using "C_STRUCTS.timeval.tv_usec" leads to a wrong offset.
-          // So, instead, we use POINTER_SIZE.
-          var tv_sec = (readfds ? {{{ makeGetValue('timeout', 0, 'i32') }}} : 0),
-              tv_usec = (readfds ? {{{ makeGetValue('timeout', POINTER_SIZE, 'i32') }}} : 0);
-          timeoutInMillis = (tv_sec + tv_usec / 1000000) * 1000;
-        }
         flags = stream.stream_ops.poll(stream, timeoutInMillis);
+      } else {
+#if ASSERTIONS
+        if (timeoutInMillis != 0) warnOnce('non-zero select() timeout not supported: ' + timeoutInMillis)
+#endif
       }
 
       if ((flags & {{{ cDefs.POLLIN }}}) && check(fd, srcReadLow, srcReadHigh, mask)) {
@@ -638,6 +632,9 @@ var SyscallsLibrary = {
     return 0; // we can't do anything synchronously; the in-memory FS is already synced to
   },
   __syscall_poll: (fds, nfds, timeout) => {
+#if ASSERTIONS
+    if (timeout != 0) warnOnce('non-zero poll() timeout not supported: ' + timeout)
+#endif
     var nonzero = 0;
     for (var i = 0; i < nfds; i++) {
       var pollfd = fds + {{{ C_STRUCTS.pollfd.__size__ }}} * i;

system/lib/libc/musl/arch/emscripten/syscall_arch.h

@@ -41,7 +41,7 @@ int __syscall_uname(intptr_t buf);
 int __syscall_mprotect(size_t addr, size_t len, int prot);
 int __syscall_getpgid(int 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__newselect(int nfds, intptr_t readfds, intptr_t writefds, intptr_t exceptfds, int64_t timeout);
 int __syscall_msync(intptr_t addr, size_t len, int flags);
 int __syscall_getsid(int pid);
 int __syscall_fdatasync(int fd);

system/lib/libc/musl/src/select/select.c

@@ -15,6 +15,10 @@ int select(int n, fd_set *restrict rfds, fd_set *restrict wfds, fd_set *restrict
 	const time_t max_time = (1ULL<<8*sizeof(time_t)-1)-1;
 
 	if (s<0 || us<0) return __syscall_ret(-EINVAL);
+#ifdef __EMSCRIPTEN__
+	uint64_t millis =  tv ? s * 1000 + (us / 1000) : -1;
+	return syscall_cp(SYS_select, n, rfds, wfds, efds, millis);
+#else
 	if (us/1000000 > max_time - s) {
 		s = max_time;
 		us = 999999;
@@ -24,7 +28,6 @@ int select(int n, fd_set *restrict rfds, fd_set *restrict wfds, fd_set *restrict
 		us %= 1000000;
 		ns = us*1000;
 	}
-
 #ifdef SYS_pselect6_time64
 	int r = -ENOSYS;
 	if (SYS_pselect6 == SYS_pselect6_time64 || !IS32BIT(s))
@@ -42,4 +45,5 @@ int select(int n, fd_set *restrict rfds, fd_set *restrict wfds, fd_set *restrict
 	return syscall_cp(SYS_pselect6, n, rfds, wfds, efds,
 		tv ? ((long[]){s, ns}) : 0, ((syscall_arg_t[]){ 0, _NSIG/8 }));
 #endif
+#endif
 }

system/lib/wasmfs/syscalls.cpp

@@ -1772,14 +1772,13 @@ int __syscall__newselect(int nfds,
                          intptr_t _readfds,
                          intptr_t _writefds,
                          intptr_t _exceptfds,
-                         intptr_t _timeout) {
+                         int64_t timeout) {
   // Implement select in terms of `poll()`
 
   // Part 1: convert select arguments into poll arguments
   fd_set* readfds = (fd_set*)_readfds;
   fd_set* writefds = (fd_set*)_writefds;
   fd_set* exceptfds = (fd_set*)_exceptfds;
-  timeval* timeout = (timeval*)_timeout;
 
   int n = 0;
   struct pollfd* fds = (struct pollfd*)calloc(nfds, sizeof(struct pollfd));
@@ -1800,14 +1799,12 @@ int __syscall__newselect(int nfds,
     }
   }
 
-  // __syscall_poll currently ignores timeout but we calculate it here for
-  // completeness.
-  int timeout_ms = -1; // Infinite
-  if (timeout) {
-    timeout_ms = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);
-  }
-
-  int rtn = __syscall_poll((intptr_t)fds, n, timeout_ms);
+  // emscripten's __syscall__newselect already takes a timeout that is
+  // compatible with __syscall_poll:
+  // -1: Block forever
+  // 0: Never block
+  // >0: Block for up to N milliseconds.
+  int rtn = __syscall_poll((intptr_t)fds, n, timeout);
   if (rtn < 0) {
     free(fds);
     return -1;

test/codesize/test_codesize_hello_dylink_all.json

@@ -1,7 +1,7 @@
 {
-  "a.out.js": 245673,
-  "a.out.nodebug.wasm": 573748,
-  "total": 819421,
+  "a.out.js": 245617,
+  "a.out.nodebug.wasm": 573657,
+  "total": 819274,
   "sent": [
     "IMG_Init",
     "IMG_Load",