[wasm64] making JS bindings wasm64 aware

Author: aardappel

embuilder.py

@@ -124,6 +124,8 @@ def main():
                       help='build relocatable objects for suitable for dynamic linking')
   parser.add_argument('--force', action='store_true',
                       help='force rebuild of target (by removing it first)')
+  parser.add_argument('--wasm64', action='store_true',
+                      help='use wasm64 architecture')
   parser.add_argument('operation', help='currently only "build" is supported')
   parser.add_argument('targets', nargs='+', help='see below')
   args = parser.parse_args()
@@ -144,6 +146,9 @@ def main():
   if args.pic:
     settings.RELOCATABLE = 1
 
+  if args.wasm64:
+    settings.MEMORY64 = 2
+
   if args.force:
     force = True
 

emscripten.py

@@ -127,6 +127,8 @@ def update_settings_glue(metadata, DEBUG):
 
   # start with the MVP features, and add any detected features.
   settings.BINARYEN_FEATURES = ['--mvp-features'] + metadata['features']
+  if settings.MEMORY64 and '--enable-memory64' not in settings.BINARYEN_FEATURES:
+    settings.BINARYEN_FEATURES += ['--enable-memory64']
   if settings.USE_PTHREADS:
     assert '--enable-threads' in settings.BINARYEN_FEATURES
   if settings.MEMORY64:

src/embind/embind.js

@@ -405,6 +405,7 @@ var LibraryEmbind = {
   },
 
   $heap32VectorToArray: function(count, firstElement) {
+    {{{ from64('firstElement') }}}
     var array = [];
     for (var i = 0; i < count; i++) {
         array.push(HEAP32[(firstElement >> 2) + i]);
@@ -476,6 +477,7 @@ var LibraryEmbind = {
 
   $getShiftFromSize__deps: [],
   $getShiftFromSize: function(size) {
+    {{{ from64('size') }}}
     switch (size) {
         case 1: return 0;
         case 2: return 1;
@@ -874,6 +876,10 @@ var LibraryEmbind = {
         Uint32Array,
         Float32Array,
         Float64Array,
+#if WASM_BIGINT
+        BigInt64Array,
+        BigUint64Array,
+#endif
     ];
 
     var TA = typeMapping[dataTypeIndex];

src/library.js

@@ -91,6 +91,7 @@ LibraryManager.library = {
   utime__proxy: 'sync',
   utime__sig: 'iii',
   utime: function(path, times) {
+    {{{ from64('times') }}};
     // int utime(const char *path, const struct utimbuf *times);
     // http://pubs.opengroup.org/onlinepubs/009695399/basedefs/utime.h.html
     var time;
@@ -294,7 +295,7 @@ LibraryManager.library = {
 
     // Memory resize rules:
     // 1. Always increase heap size to at least the requested size, rounded up to next page multiple.
-    // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap geometrically: increase the heap size according to 
+    // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap geometrically: increase the heap size according to
     //                                         MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%),
     //                                         At most overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
     // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap linearly: increase the heap size by at least MEMORY_GROWTH_LINEAR_STEP bytes.
@@ -519,6 +520,7 @@ LibraryManager.library = {
 
   time__sig: 'ii',
   time: function(ptr) {
+    {{{ from64('ptr') }}};
     var ret = (Date.now()/1000)|0;
     if (ptr) {
       {{{ makeSetValue('ptr', 0, 'ret', 'i32') }}};
@@ -722,7 +724,7 @@ LibraryManager.library = {
     var summerOffset = summer.getTimezoneOffset();
 
     // Local standard timezone offset. Local standard time is not adjusted for daylight savings.
-    // This code uses the fact that getTimezoneOffset returns a greater value during Standard Time versus Daylight Saving Time (DST). 
+    // This code uses the fact that getTimezoneOffset returns a greater value during Standard Time versus Daylight Saving Time (DST).
     // Thus it determines the expected output during Standard Time, and it compares whether the output of the given date the same (Standard) or less (DST).
     var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
 
@@ -3254,6 +3256,7 @@ LibraryManager.library = {
   $readAsmConstArgsArray: '=[]',
   $readAsmConstArgs__deps: ['$readAsmConstArgsArray'],
   $readAsmConstArgs: function(sigPtr, buf) {
+    {{{ from64(['sigPtr', 'buf']) }}};
 #if ASSERTIONS
     // Nobody should have mutated _readAsmConstArgsArray underneath us to be something else than an array.
     assert(Array.isArray(readAsmConstArgsArray));
@@ -3771,20 +3774,26 @@ LibraryManager.library = {
   // mode are created here and imported by the module.
   // Mark with `__import` so these are usable from native code.  This is needed
   // because, by default, only functions can be be imported.
-  __stack_pointer: "new WebAssembly.Global({'value': 'i32', 'mutable': true}, {{{ STACK_BASE }}})",
+  __stack_pointer:
+    "new WebAssembly.Global({'value': '{{{ SIZE_TYPE }}}', 'mutable': true}, {{{ to64(STACK_BASE) }}})",
   __stack_pointer__import: true,
   // tell the memory segments where to place themselves
-  __memory_base: '{{{ GLOBAL_BASE }}}',
+  __memory_base:
+    "new WebAssembly.Global({'value': '{{{ SIZE_TYPE}}}', 'mutable': false}, {{{ to64(GLOBAL_BASE) }}})",
   __memory_base__import: true,
   // the wasm backend reserves slot 0 for the NULL function pointer
-  __table_base: 1,
+  __table_base:
+    "new WebAssembly.Global({'value': '{{{ SIZE_TYPE }}}', 'mutable': false}, {{{ to64(1) }}})",
   __table_base__import: true,
+#if MEMORY64
+  __table_base32: 1,
+#endif
   // To support such allocations during startup, track them on __heap_base and
   // then when the main module is loaded it reads that value and uses it to
   // initialize sbrk (the main module is relocatable itself, and so it does not
   // have __heap_base hardcoded into it - it receives it from JS as an extern
   // global, basically).
-  __heap_base: '{{{ HEAP_BASE }}}',
+  __heap_base: '{{{ to64(HEAP_BASE) }}}',
   __heap_base__import: true,
 #endif
 };

src/library_dylink.js

@@ -43,7 +43,13 @@ var LibraryDylink = {
   $GOTHandler: {
     'get': function(obj, symName) {
       if (!GOT[symName]) {
-        GOT[symName] = new WebAssembly.Global({'value': 'i32', 'mutable': true});
+        GOT[symName] = new WebAssembly.Global({'value':
+#if MEMORY64
+          'i64',
+#else
+          'i32',
+#endif
+          'mutable': true});
 #if DYLINK_DEBUG
         err("new GOT entry: " + symName);
 #endif
@@ -97,6 +103,8 @@ var LibraryDylink = {
 #endif
         } else if (typeof value === 'number') {
           GOT[symName].value = value;
+        } else if (typeof value === 'bigint') {
+          GOT[symName].value = Number(value);
         } else {
           err("unhandled export type for `" + symName + "`: " + (typeof value));
         }

src/library_exceptions.js

@@ -120,15 +120,17 @@ var LibraryExceptions = {
     };
 
     this.set_adjusted_ptr = function(adjustedPtr) {
-      {{{ makeSetValue('this.ptr', Runtime.POINTER_SIZE, 'adjustedPtr', '*') }}};
+      var ptrSize = {{{ `${Runtime.POINTER_SIZE}` }}};
+      {{{ makeSetValue('this.ptr', 'ptrSize', 'adjustedPtr', '*') }}};
     };
 
     this.get_adjusted_ptr_addr = function() {
       return this.ptr + {{{ Runtime.POINTER_SIZE }}};
     }
 
     this.get_adjusted_ptr = function() {
-      return {{{ makeGetValue('this.ptr', Runtime.POINTER_SIZE, '*') }}};
+      var ptrSize = {{{ `${Runtime.POINTER_SIZE}` }}};
+      return {{{ makeGetValue('this.ptr', 'ptrSize', '*') }}};
     };
 
     // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted
@@ -153,7 +155,7 @@ var LibraryExceptions = {
     };
 
     if (ptr === undefined) {
-      this.ptr = _malloc({{{ Runtime.POINTER_SIZE * 2 }}});
+      this.ptr = _malloc({{{ `${Runtime.POINTER_SIZE}` * 2 }}});
       this.set_adjusted_ptr(0);
     } else {
       this.ptr = ptr;

src/library_formatString.js

@@ -52,6 +52,7 @@ mergeInto(LibraryManager.library, {
 #endif
   ],
   $formatString: function(format, varargs) {
+    {{{ from64(['format', 'varargs']) }}};
 #if ASSERTIONS
     assert((varargs & 3) === 0);
 #endif
@@ -470,6 +471,7 @@ mergeInto(LibraryManager.library, {
   // printf/puts/strlen implementations for when musl is not pulled in - very
   // partial. useful for tests, and when bootstrapping structInfo
   strlen: function(ptr) {
+    {{{ from64('ptr') }}};
     var end = ptr;
     while (HEAPU8[end]) ++end;
     return end - ptr;

src/library_glfw.js

@@ -1241,7 +1241,7 @@ var LibraryGLFW = {
   glfwGetMonitors: function(count) {
     setValue(count, 1, 'i32');
     if (!GLFW.monitors) {
-      GLFW.monitors = {{{ makeMalloc('glfwGetMonitors', Runtime.POINTER_SIZE) }}};
+      GLFW.monitors = {{{ makeMalloc('glfwGetMonitors', `${Runtime.POINTER_SIZE}`) }}};
       setValue(GLFW.monitors, 1, 'i32');
     }
     return GLFW.monitors;

src/library_syscall.js

@@ -679,7 +679,7 @@ var SyscallsLibrary = {
     for (var i = 0; i < num; i++) {
       var iovbase = {{{ makeGetValue('iov', '(' + C_STRUCTS.iovec.__size__ + ' * i) + ' + C_STRUCTS.iovec.iov_base, 'i8*') }}};
       var iovlen = {{{ makeGetValue('iov', '(' + C_STRUCTS.iovec.__size__ + ' * i) + ' + C_STRUCTS.iovec.iov_len, 'i32') }}};
-      for (var j = 0; j < iovlen; j++) {  
+      for (var j = 0; j < iovlen; j++) {
         view[offset++] = {{{ makeGetValue('iovbase', 'j', 'i8') }}};
       }
     }
@@ -796,7 +796,7 @@ var SyscallsLibrary = {
 #endif
 
     var total = 0;
-    
+
     var srcReadLow = (readfds ? {{{ makeGetValue('readfds', 0, 'i32') }}} : 0),
         srcReadHigh = (readfds ? {{{ makeGetValue('readfds', 4, 'i32') }}} : 0);
     var srcWriteLow = (writefds ? {{{ makeGetValue('writefds', 0, 'i32') }}} : 0),
@@ -863,7 +863,7 @@ var SyscallsLibrary = {
       {{{ makeSetValue('exceptfds', '0', 'dstExceptLow', 'i32') }}};
       {{{ makeSetValue('exceptfds', '4', 'dstExceptHigh', 'i32') }}};
     }
-    
+
     return total;
   },
   __sys_msync: function(addr, len, flags) {
@@ -1425,6 +1425,18 @@ function wrapSyscallFunction(x, library, isWasi) {
     var bodyEnd = t.lastIndexOf('}');
     t = t.substring(0, bodyEnd) + post + t.substring(bodyEnd);
   }
+
+  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 BigInt((function ' + name + '_inner(' + args + ') {\n' +
+             body +
+             '  })(' + argnums + '));' +
+             '}';
+    });
+  }
+
   library[x] = eval('(' + t + ')');
   if (!library[x + '__deps']) library[x + '__deps'] = [];
   library[x + '__deps'].push('$SYSCALLS');

src/library_wasi.js

@@ -90,15 +90,16 @@ var WasiLibrary = {
   args_sizes_get__nothrow: true,
   args_sizes_get__sig: 'iii',
   args_sizes_get: function(pargc, pargv_buf_size) {
+    {{{ from64(['pargc', 'pargv_buf_size']) }}};
 #if MAIN_READS_PARAMS
-    {{{ makeSetValue('pargc', 0, 'mainArgs.length', 'i32') }}};
+    {{{ makeSetValue('pargc', 0, 'mainArgs.length', `${SIZE_TYPE}`) }}};
     var bufSize = 0;
     mainArgs.forEach(function(arg) {
       bufSize += arg.length + 1;
     });
-    {{{ makeSetValue('pargv_buf_size', 0, 'bufSize', 'i32') }}};
+    {{{ makeSetValue('pargv_buf_size', 0, 'bufSize', `${SIZE_TYPE}`) }}};
 #else
-    {{{ makeSetValue('pargc', 0, '0', 'i32') }}};
+    {{{ makeSetValue('pargc', 0, '0', `${SIZE_TYPE}`) }}};
 #endif
     return 0;
   },
@@ -109,11 +110,12 @@ var WasiLibrary = {
   args_get__deps: ['$writeAsciiToMemory'],
 #endif
   args_get: function(argv, argv_buf) {
+    {{{ from64(['argv', 'argv_buf']) }}};
 #if MAIN_READS_PARAMS
     var bufSize = 0;
     mainArgs.forEach(function(arg, i) {
       var ptr = argv_buf + bufSize;
-      {{{ makeSetValue('argv', 'i * 4', 'ptr', 'i32') }}};
+      {{{ makeSetValue('argv', `i*${Runtime.POINTER_SIZE}`, 'ptr', `${POINTER_TYPE}`) }}};
       writeAsciiToMemory(arg, ptr);
       bufSize += arg.length + 1;
     });
@@ -181,7 +183,7 @@ var WasiLibrary = {
 #if SYSCALLS_REQUIRE_FILESYSTEM == 0 && (!MINIMAL_RUNTIME || EXIT_RUNTIME)
   $flush_NO_FILESYSTEM: function() {
     // flush anything remaining in the buffers during shutdown
-    if (typeof _fflush !== 'undefined') _fflush(0);
+    if (typeof _fflush !== 'undefined') _fflush({{{ sizeT(0) }}});
     var buffers = SYSCALLS.buffers;
     if (buffers[1].length) SYSCALLS.printChar(1, {{{ charCode("\n") }}});
     if (buffers[2].length) SYSCALLS.printChar(2, {{{ charCode("\n") }}});
@@ -193,22 +195,23 @@ var WasiLibrary = {
 #endif
   fd_write__sig: 'iiiii',
   fd_write: function(fd, iov, iovcnt, pnum) {
+    {{{ from64(['iov', 'iovcnt', 'pnum']) }}};
 #if SYSCALLS_REQUIRE_FILESYSTEM
     var stream = SYSCALLS.getStreamFromFD(fd);
     var num = SYSCALLS.doWritev(stream, iov, iovcnt);
 #else
     // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
     var num = 0;
     for (var i = 0; i < iovcnt; i++) {
-      var ptr = {{{ makeGetValue('iov', 'i*8', 'i32') }}};
-      var len = {{{ makeGetValue('iov', 'i*8 + 4', 'i32') }}};
+      var ptr = {{{ makeGetValue('iov', `i*${Runtime.POINTER_SIZE}*2`, `${POINTER_TYPE}`) }}};
+      var len = {{{ makeGetValue('iov', `i*${Runtime.POINTER_SIZE}*2 + ${Runtime.POINTER_SIZE}`, `${POINTER_TYPE}`) }}};
       for (var j = 0; j < len; j++) {
         SYSCALLS.printChar(fd, HEAPU8[ptr+j]);
       }
       num += len;
     }
 #endif // SYSCALLS_REQUIRE_FILESYSTEM
-    {{{ makeSetValue('pnum', 0, 'num', 'i32') }}}
+    {{{ makeSetValue('pnum', 0, 'num', `${SIZE_TYPE}`) }}}
     return 0;
   },