[wasm64] Fix for bad Memory initial size under firefox

Recent versions of firefox started requiring bigint values for initial
and max memory.

See WebAssembly/memory64#68

Fixes: #22486

Author: sbc100

.circleci/config.yml

@@ -850,6 +850,7 @@ jobs:
           # further blocked by issue #6897.
           test_targets: "
             browser64.test_sdl_image
+            browser64.test_dylink_many
             browser
             skip:browser.test_sdl2_mouse
             skip:browser.test_html5_webgl_create_context

src/library.js

@@ -1966,41 +1966,38 @@ addToLibrary({
   $setWasmTableEntry__internal: true,
   $setWasmTableEntry__deps: ['$wasmTableMirror', '$wasmTable'],
   $setWasmTableEntry: (idx, func) => {
-    wasmTable.set(idx, func);
+    wasmTable.set({{{ toIndexType('idx') }}}, func);
     // With ABORT_ON_WASM_EXCEPTIONS wasmTable.get is overridden to return wrapped
     // functions so we need to call it here to retrieve the potential wrapper correctly
     // instead of just storing 'func' directly into wasmTableMirror
-    wasmTableMirror[idx] = wasmTable.get(idx);
+    wasmTableMirror[idx] = wasmTable.get({{{ toIndexType('idx') }}});
   },
 
   $getWasmTableEntry__internal: true,
   $getWasmTableEntry__deps: ['$wasmTableMirror', '$wasmTable'],
   $getWasmTableEntry: (funcPtr) => {
-#if MEMORY64
-    // Function pointers are 64-bit, but wasmTable.get() requires a Number.
-    // https://github.com/emscripten-core/emscripten/issues/18200
-    funcPtr = Number(funcPtr);
-#endif
+    // Pointers are expected to be JS numbers, even under wasm64
+    assert(typeof funcPtr == 'number');
     var func = wasmTableMirror[funcPtr];
     if (!func) {
       if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
-      wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+      wasmTableMirror[funcPtr] = func = wasmTable.get({{{ toIndexType('funcPtr') }}});
 #if ASYNCIFY == 2
       if (Asyncify.isAsyncExport(func)) {
         wasmTableMirror[funcPtr] = func = Asyncify.makeAsyncFunction(func);
       }
 #endif
     }
 #if ASSERTIONS && ASYNCIFY != 2 // With JSPI the function stored in the table will be a wrapper.
-    assert(wasmTable.get(funcPtr) == func, 'JavaScript-side Wasm function table mirror is out of date!');
+    assert(wasmTable.get({{{ toIndexType('funcPtr') }}}) == func, 'JavaScript-side Wasm function table mirror is out of date!');
 #endif
     return func;
   },
 
 #else
 
   $setWasmTableEntry__deps: ['$wasmTable'],
-  $setWasmTableEntry: (idx, func) => wasmTable.set(idx, func),
+  $setWasmTableEntry: (idx, func) => wasmTable.set({{{ toIndexType('idx') }}}, func),
 
   $getWasmTableEntry__deps: ['$wasmTable'],
   $getWasmTableEntry: (funcPtr) => {
@@ -2391,9 +2388,9 @@ addToLibrary({
 #if RELOCATABLE
   // In RELOCATABLE mode we create the table in JS.
   $wasmTable: `=new WebAssembly.Table({
-  'initial': {{{ INITIAL_TABLE }}},
+  'initial': {{{ toIndexType(INITIAL_TABLE) }}},
 #if !ALLOW_TABLE_GROWTH
-  'maximum': {{{ INITIAL_TABLE }}},
+  'maximum': {{{ toIndexType(INITIAL_TABLE) }}},
 #endif
 #if MEMORY64 == 1
   'index': 'i64',

src/library_addfunction.js

@@ -151,14 +151,14 @@ addToLibrary({
     }
     // Grow the table
     try {
-      wasmTable.grow(1);
+      wasmTable.grow({{{ toIndexType('1') }}});
     } catch (err) {
       if (!(err instanceof RangeError)) {
         throw err;
       }
       throw 'Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.';
     }
-    return wasmTable.length - 1;
+    return {{{ from64Expr('wasmTable.length') }}} - 1;
   },
 
   $updateTableMap__deps: ['$getWasmTableEntry'],
@@ -179,7 +179,7 @@ addToLibrary({
     // First, create the map if this is the first use.
     if (!functionsInTableMap) {
       functionsInTableMap = new WeakMap();
-      updateTableMap(0, wasmTable.length);
+      updateTableMap(0, {{{ from64Expr('wasmTable.length') }}});
     }
     return functionsInTableMap.get(func) || 0;
   },

src/library_dylink.js

@@ -581,8 +581,9 @@ var LibraryDylink = {
 #if DYLINK_DEBUG
   $dumpTable__deps: ['$wasmTable'],
   $dumpTable: () => {
-    for (var i = 0; i < wasmTable.length; i++)
-      dbg(`table: ${i} : ${wasmTable.get(i)}`);
+    var len = {{{ from64Expr('wasmTable.length') }}};
+    for (var i = 0; i < len; i++)
+      dbg(`table: ${i} : ${wasmTable.get({{{ to64(i) }}})}`);
   },
 #endif
 
@@ -641,7 +642,7 @@ var LibraryDylink = {
         tableBase = {{{ makeGetValue('handle', C_STRUCTS.dso.table_addr, '*') }}};
       }
 
-      var tableGrowthNeeded = tableBase + metadata.tableSize - wasmTable.length;
+      var tableGrowthNeeded = tableBase + metadata.tableSize - {{{ from64Expr('wasmTable.length') }}};
       if (tableGrowthNeeded > 0) {
 #if DYLINK_DEBUG
         dbg("loadModule: growing table: " + tableGrowthNeeded);

src/parseTools.mjs

@@ -963,6 +963,13 @@ function from64Expr(x, assign = true) {
   return `Number(${x})`;
 }
 
+function toIndexType(val) {
+  if (MEMORY64 == 1) {
+    return `toIndexType(${val})`;
+  }
+  return val;
+}
+
 function to64(x) {
   if (!MEMORY64) return x;
   return `BigInt(${x})`;
@@ -1153,4 +1160,5 @@ addToCompileTimeContext({
   splitI64,
   storeException,
   to64,
+  toIndexType,
 });

src/runtime_init_memory.js

@@ -9,6 +9,23 @@
 {{{ throw "this file should not be be included when IMPORTED_MEMORY is set"; }}}
 #endif
 
+#if MEMORY64 == 1
+var toIndexType = (function() {
+  // Probe for support of bigint bounds with memory64.
+  // TODO(sbc): Remove this once all browsers start requiring bigint here.
+  // See https://github.com/WebAssembly/memory64/issues/68
+  var bigintMemoryBounds = 1;
+  try {
+    /** @suppress {checkTypes} */
+    new WebAssembly.Memory({'initial': 1n, 'index': 'i64'})
+  } catch (e) {
+    console.log(e);
+    bigintMemoryBounds = 0;
+  }
+  return (i) => bigintMemoryBounds ? BigInt(i) : i;
+})();
+#endif
+
 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 
 #if PTHREADS
@@ -27,16 +44,16 @@ if (!ENVIRONMENT_IS_PTHREAD) {
     assert(INITIAL_MEMORY >= {{{STACK_SIZE}}}, 'INITIAL_MEMORY should be larger than STACK_SIZE, was ' + INITIAL_MEMORY + '! (STACK_SIZE=' + {{{STACK_SIZE}}} + ')');
 #endif
     wasmMemory = new WebAssembly.Memory({
-      'initial': INITIAL_MEMORY / {{{ WASM_PAGE_SIZE }}},
+      'initial': {{{ toIndexType(`INITIAL_MEMORY / ${WASM_PAGE_SIZE}`) }}},
 #if ALLOW_MEMORY_GROWTH
       // In theory we should not need to emit the maximum if we want "unlimited"
       // or 4GB of memory, but VMs error on that atm, see
       // https://github.com/emscripten-core/emscripten/issues/14130
       // And in the pthreads case we definitely need to emit a maximum. So
       // always emit one.
-      'maximum': {{{ MAXIMUM_MEMORY }}} / {{{ WASM_PAGE_SIZE }}},
+      'maximum': {{{ toIndexType(MAXIMUM_MEMORY / WASM_PAGE_SIZE) }}},
 #else
-      'maximum': INITIAL_MEMORY / {{{ WASM_PAGE_SIZE }}},
+      'maximum': {{{ toIndexType(`INITIAL_MEMORY / ${WASM_PAGE_SIZE}`) }}},
 #endif // ALLOW_MEMORY_GROWTH
 #if SHARED_MEMORY
       'shared': true,