[wasm64] making JS bindings wasm64 aware

Author: aardappel

embuilder.py

@@ -125,6 +125,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()
@@ -145,6 +147,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,9 @@ def update_settings_glue(metadata, DEBUG):
 
   # start with the MVP features, and add any detected features.
   settings.BINARYEN_FEATURES = ['--mvp-features'] + metadata['features']
+  # ensure '--enable-memory64' is set exactly once:
+  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;
@@ -523,6 +524,7 @@ LibraryManager.library = {
 
   time__sig: 'ii',
   time: function(ptr) {
+    {{{ from64('ptr') }}};
     var ret = (Date.now()/1000)|0;
     if (ptr) {
       {{{ makeSetValue('ptr', 0, 'ret', 'i32') }}};
@@ -3260,6 +3262,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));
@@ -3769,20 +3772,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
@@ -101,6 +107,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_pthread.js

@@ -667,7 +667,11 @@ var LibraryPThread = {
     // Deduce which WebGL canvases (HTMLCanvasElements or OffscreenCanvases) should be passed over to the
     // Worker that hosts the spawned pthread.
     // Comma-delimited list of CSS selectors that must identify canvases by IDs: "#canvas1, #canvas2, ..."
-    var transferredCanvasNames = attr ? {{{ makeGetValue('attr', 36, 'i32') }}} : 0;
+#if MEMORY64
+    var transferredCanvasNames = attr ? {{{ makeGetValue('attr', 40, 'i64') }}} : 0;
+#else
+    var transferredCanvasNames = attr ? {{{ makeGetValue('attr', 40, 'i32') }}} : 0;
+#endif
 #if OFFSCREENCANVASES_TO_PTHREAD
     // Proxied canvases string pointer -1 is used as a special token to fetch
     // whatever canvases were passed to build in -s

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');