Convert BigInt<->Number based on library function __sig attributes

This change introduces and type to the `__sig` scheme that we using for
library functions: 'p'.  This letter signifies that the paramater or
return value is the width of a pointer which means it will differ
between wasm32 and wasm64.

We use this whenever a JS function receives or returns pointer type or a
size_t type.

For wasm32, we don't need to do anything since the incoming value is and
i32.  For wasm64 we covert the incoming BigInt value to an int53/double
at the JS/Wasm boundary.  At the moment no checking is done on the
values, which means values that don't pricely convert to JS double can
be currupted/truncated.  As a followup, we could consider using the
checking coversion functions, or asserting in debug builds if the values
don't fit within this range.

Author: sbc100

.circleci/config.yml

@@ -380,7 +380,7 @@ jobs:
     executor: bionic
     steps:
       - run-tests-linux:
-          test_targets: "wasm64.test_hello_world wasm64l.test_hello_world wasm64l.test_unistd_truncate wasm64l.test_mmap"
+          test_targets: "wasm64.test_hello_world wasm64l.test_hello_world wasm64l.test_unistd_truncate wasm64l.test_mmap wasm64l.test_unistd_sysconf_phys_pages"
   test-other:
     executor: bionic
     steps:

src/jsifier.js

@@ -90,6 +90,44 @@ function runJSify(functionsOnly) {
     });
   }
 
+  function convertPointerParams(snippet, sig) {
+    // Automatically convert any incoming pointer arguments from BigInt
+    // to double (this limits the range to int53).
+    // And convert the return value if the function returns a pointer.
+    return modifyFunction(snippet, (name, args, body) => {
+      const argNames = args.split(',');
+      let newArgs = [];
+      let argConvertions = '';
+      for (let i = 1; i < sig.length; i++) {
+        const name = argNames[i - 1];
+        if (sig[i] == 'p') {
+          argConvertions += `${name} = Number(${name})\n`;
+          newArgs.push(`Number(${name})`);
+        } else {
+          newArgs.push(name);
+        }
+      }
+      newArgs = newArgs.join(',');
+      if (sig[0] == 'p') {
+        // For function that return a pointer need need to convert
+        // the return value too, which means we need to wrap the
+        // body in an inner function.
+        return `\
+function ${name}(${args}) {
+  var ret = ((${args}) => { ${body} })(${newArgs});
+  return BigInt(ret);
+}`;
+      }
+      // Othewise no inner function is needed and we covert the arguments
+      // before executing the function body.
+      return `\
+function ${name}(${args}) {
+  ${argConvertions};
+  ${body};
+}`;
+    });
+  }
+
   function processLibraryFunction(snippet, ident, finalName) {
     // It is possible that when printing the function as a string on Windows, the js interpreter we are in returns the string with Windows
     // line endings \r\n. This is undesirable, since line endings are managed in the form \n in the output for binary file writes, so
@@ -110,6 +148,12 @@ function ${name}(${args}) {
   return ret;
 }`);
     }
+    if (MEMORY64) {
+      const sig = LibraryManager.library[ident + '__sig'];
+      if (sig && sig.includes('p')) {
+        snippet = convertPointerParams(snippet, sig);
+      }
+    }
     return snippet;
   }
 

src/library.js

@@ -87,6 +87,8 @@ LibraryManager.library = {
   },
 #endif
 
+  // Returns a pointer ('p'), which means an i32 on wasm32 and an i64 wasm64
+  emscripten_get_heap_max__sig: 'p',
   emscripten_get_heap_max: function() {
 #if ALLOW_MEMORY_GROWTH
     // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
@@ -357,6 +359,7 @@ LibraryManager.library = {
   // the wasm file standalone.
 #if SHRINK_LEVEL < 2 && !STANDALONE_WASM
 
+  emscripten_memcpy_big__sig: 'vppp',
 #if MIN_CHROME_VERSION < 45 || MIN_EDGE_VERSION < 14 || MIN_FIREFOX_VERSION < 34 || MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION < 100101
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin lists browsers that support TypedArray.prototype.copyWithin, but it
   // has outdated information for Safari, saying it would not support it.

src/library_syscall.js

@@ -154,6 +154,7 @@ var SyscallsLibrary = {
 #endif
   },
 
+  __syscall_chdir__sig: 'ip',
   __syscall_chdir: function(path) {
     path = SYSCALLS.getStr(path);
     FS.chdir(path);
@@ -164,22 +165,26 @@ var SyscallsLibrary = {
     FS.chmod(path, mode);
     return 0;
   },
+  __syscall_rename__sig: 'ipp',
   __syscall_rename: function(old_path, new_path) {
     old_path = SYSCALLS.getStr(old_path);
     new_path = SYSCALLS.getStr(new_path);
     FS.rename(old_path, new_path);
     return 0;
   },
+  __syscall_rmdir__sig: 'ip',
   __syscall_rmdir: function(path) {
     path = SYSCALLS.getStr(path);
     FS.rmdir(path);
     return 0;
   },
+  __syscall_dup__sig: 'ii',
   __syscall_dup: function(fd) {
     var old = SYSCALLS.getStreamFromFD(fd);
     return FS.createStream(old, 0).fd;
   },
   __syscall_pipe__deps: ['$PIPEFS'],
+  __syscall_pipe__sig: 'ip',
   __syscall_pipe: function(fdPtr) {
     if (fdPtr == 0) {
       throw new FS.ErrnoError({{{ cDefine('EFAULT') }}});
@@ -192,6 +197,7 @@ var SyscallsLibrary = {
 
     return 0;
   },
+  __syscall_ioctl__sig: 'iiip',
   __syscall_ioctl: function(fd, op, varargs) {
 #if SYSCALLS_REQUIRE_FILESYSTEM == 0
 #if SYSCALL_DEBUG
@@ -582,6 +588,7 @@ var SyscallsLibrary = {
     var stream = SYSCALLS.getStreamFromFD(fd);
     return 0; // we can't do anything synchronously; the in-memory FS is already synced to
   },
+  __syscall_poll__sig: 'ipi',
   __syscall_poll: function(fds, nfds, timeout) {
     var nonzero = 0;
     for (var i = 0; i < nfds; i++) {
@@ -602,6 +609,7 @@ var SyscallsLibrary = {
     }
     return nonzero;
   },
+  __syscall_getcwd__sig: 'ipp',
   __syscall_getcwd: function(buf, size) {
     if (size === 0) return -{{{ cDefine('EINVAL') }}};
     var cwd = FS.cwd();
@@ -610,25 +618,30 @@ var SyscallsLibrary = {
     stringToUTF8(cwd, buf, size);
     return cwdLengthInBytes;
   },
+  __syscall_truncate64__sig: 'ipj',
   __syscall_truncate64: function(path, {{{ defineI64Param('length') }}}) {
     {{{ receiveI64ParamAsDouble('length') }}}
     path = SYSCALLS.getStr(path);
     FS.truncate(path, length);
     return 0;
   },
+  __syscall_ftruncate64__sig: 'iij',
   __syscall_ftruncate64: function(fd, {{{ defineI64Param('length') }}}) {
     {{{ receiveI64ParamAsDouble('length') }}}
     FS.ftruncate(fd, length);
     return 0;
   },
+  __syscall_stat64__sig: 'iip',
   __syscall_stat64: function(path, buf) {
     path = SYSCALLS.getStr(path);
     return SYSCALLS.doStat(FS.stat, path, buf);
   },
+  __syscall_lstat64__sig: 'iip',
   __syscall_lstat64: function(path, buf) {
     path = SYSCALLS.getStr(path);
     return SYSCALLS.doStat(FS.lstat, path, buf);
   },
+  __syscall_fstat64__sig: 'iip',
   __syscall_fstat64: function(fd, buf) {
     var stream = SYSCALLS.getStreamFromFD(fd);
     return SYSCALLS.doStat(FS.stat, stream.path, buf);
@@ -637,6 +650,7 @@ var SyscallsLibrary = {
     FS.fchown(fd, owner, group);
     return 0;
   },
+  __syscall_getdents64__sig: 'iipi',
   __syscall_getdents64: function(fd, dirp, count) {
     var stream = SYSCALLS.getStreamFromFD(fd)
     if (!stream.getdents) {
@@ -685,6 +699,7 @@ var SyscallsLibrary = {
     return pos;
   },
   __syscall_fcntl64__deps: ['$setErrNo'],
+  __syscall_fcntl64__sig: 'iipp',
   __syscall_fcntl64: function(fd, cmd, varargs) {
 #if SYSCALLS_REQUIRE_FILESYSTEM == 0
 #if SYSCALL_DEBUG
@@ -775,6 +790,7 @@ var SyscallsLibrary = {
   __syscall_fadvise64: function(fd, offset, len, advice) {
     return 0; // your advice is important to us (but we can't use it)
   },
+  __syscall_openat__sig: 'iipip',
   __syscall_openat: function(dirfd, path, flags, varargs) {
     path = SYSCALLS.getStr(path);
     path = SYSCALLS.calculateAt(dirfd, path);
@@ -838,6 +854,7 @@ var SyscallsLibrary = {
     path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
     return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf);
   },
+  __syscall_unlinkat__sig: 'iipi',
   __syscall_unlinkat: function(dirfd, path, flags) {
     path = SYSCALLS.getStr(path);
     path = SYSCALLS.calculateAt(dirfd, path);
@@ -871,6 +888,7 @@ var SyscallsLibrary = {
     FS.symlink(target, linkpath);
     return 0;
   },
+  __syscall_readlinkat__sig: 'vippp',
   __syscall_readlinkat: function(dirfd, path, buf, bufsize) {
     path = SYSCALLS.getStr(path);
     path = SYSCALLS.calculateAt(dirfd, path);
@@ -921,6 +939,7 @@ var SyscallsLibrary = {
     }
     return 0;
   },
+  __syscall_utimensat__sig: 'iippi',
   __syscall_utimensat: function(dirfd, path, times, flags) {
     path = SYSCALLS.getStr(path);
 #if ASSERTIONS
@@ -1043,17 +1062,6 @@ function wrapSyscallFunction(x, library, isWasi) {
     });
   }
 
-  if (MEMORY64 && !isWasi) {
-    t = modifyFunction(t, function(name, args, body) {
-      var argnums = args.split(",").map((a) => 'Number(' + a + ')').join();
-      return 'function ' + name + '(' + args + ') {\n' +
-             '  return (function ' + name + '_inner(' + args + ') {\n' +
-             body +
-             '  })(' + argnums + ');' +
-             '}';
-    });
-  }
-
   library[x] = eval('(' + t + ')');
   if (!library[x + '__deps']) library[x + '__deps'] = [];
   library[x + '__deps'].push('$SYSCALLS');

tests/test_core.py

@@ -9267,10 +9267,10 @@ def setUp(self):
 corez = make_run('corez', emcc_args=['-Oz'])
 
 # MEMORY64=1
-wasm64 = make_run('wasm64', emcc_args=[], settings={'MEMORY64': 1},
+wasm64 = make_run('wasm64', emcc_args=['--profiling-funcs'], settings={'MEMORY64': 1},
                   require_v8=True, v8_args=['--experimental-wasm-memory64'])
 # MEMORY64=2, or "lowered"
-wasm64l = make_run('wasm64l', emcc_args=[], settings={'MEMORY64': 2},
+wasm64l = make_run('wasm64l', emcc_args=['--profiling-funcs'], settings={'MEMORY64': 2},
                    node_args=['--experimental-wasm-bigint'])
 
 lto0 = make_run('lto0', emcc_args=['-flto', '-O0'])

tools/wasm2c.py

@@ -20,6 +20,11 @@ def s_to_c(s):
     return 'u32'
   elif s == 'j':
     return 'u64'
+  elif s == 'p':
+    if settings.MEMORY64:
+      return 'u64'
+    else:
+      return 'u32'
   elif s == 'f':
     return 'f32'
   elif s == 'd':