Implement macros {{{ ptrToIdx() }}}, {{{ convertPtrToIdx() }}}, {{{ idxToPtr() }}} to help 2GB, 4GB and MEMORY64 memory modes. Remove {{{ to64() }}} and {{{ from64() }}} since they had an awkward mismatch of in-place vs expression styles.

This is a looser form of PR #15433, and it embraces the idea that pointer values in JavaScript side will not need to retain the full 64-bit values, but can be truncated to 53 bits.

Update library_html5.js for >2GB

Address review and fix convertPtrToIdx on non-byte shifts

Author: juj

src/library.js

@@ -3215,6 +3215,9 @@ addToLibrary({
     // Function pointers are 64-bit, but wasmTable.get() requires a Number.
     // https://github.com/emscripten-core/emscripten/issues/18200
     funcPtr = Number(funcPtr);
+#endif
+#if ASSERTIONS
+    assert(funcPtr >= 0, "Function pointers must be nonnegative!");
 #endif
     var func = wasmTableMirror[funcPtr];
     if (!func) {
@@ -3241,6 +3244,9 @@ addToLibrary({
     // Function pointers are 64-bit, but wasmTable.get() requires a Number.
     // https://github.com/emscripten-core/emscripten/issues/18200
     funcPtr = Number(funcPtr);
+#endif
+#if ASSERTIONS
+    assert(funcPtr >= 0, "Function pointers must be nonnegative!");
 #endif
     // In -Os and -Oz builds, do not implement a JS side wasm table mirror for small
     // code size, but directly access wasmTable, which is a bit slower as uncached.
@@ -3514,11 +3520,11 @@ addToLibrary({
 #if RELOCATABLE
   // Globals that are normally exported from the wasm module but in relocatable
   // mode are created here and imported by the module.
-  __stack_pointer: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': true}, {{{ to64(STACK_HIGH) }}})",
+  __stack_pointer: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': true}, {{{ idxToPtr(STACK_HIGH) }}})",
   // tell the memory segments where to place themselves
-  __memory_base: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': false}, {{{ to64(GLOBAL_BASE) }}})",
+  __memory_base: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': false}, {{{ idxToPtr(GLOBAL_BASE) }}})",
   // the wasm backend reserves slot 0 for the NULL function pointer
-  __table_base: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': false}, {{{ to64(1) }}})",
+  __table_base: "new WebAssembly.Global({'value': '{{{ POINTER_WASM_TYPE }}}', 'mutable': false}, {{{ idxToPtr(1) }}})",
 #if MEMORY64 == 2
   __memory_base32: "new WebAssembly.Global({'value': 'i32', 'mutable': false}, {{{ GLOBAL_BASE }}})",
 #endif

src/library_ccall.js

@@ -27,30 +27,29 @@ addToLibrary({
     // For fast lookup of conversion functions
     var toC = {
 #if MEMORY64
-      'pointer': (p) => {{{ to64('p') }}},
+      'pointer': (p) => {{{ idxToPtr('p') }}},
 #endif
       'string': (str) => {
         var ret = 0;
         if (str !== null && str !== undefined && str !== 0) { // null string
           // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
           ret = stringToUTF8OnStack(str);
         }
-        return {{{ to64('ret') }}};
+        return {{{ idxToPtr('ret') }}};
       },
       'array': (arr) => {
         var ret = stackAlloc(arr.length);
         writeArrayToMemory(arr, ret);
-        return {{{ to64('ret') }}};
+        return {{{ idxToPtr('ret') }}};
       }
     };
 
     function convertReturnValue(ret) {
       if (returnType === 'string') {
-        {{{ from64('ret') }}}
-        return UTF8ToString(ret);
+        return UTF8ToString({{{ ptrToIdx('ret') }}});
       }
 #if MEMORY64
-      if (returnType === 'pointer') return Number(ret);
+      if (returnType === 'pointer') return {{{ ptrToIdx('ret') }}};
 #endif
       if (returnType === 'boolean') return Boolean(ret);
       return ret;

src/library_dylink.js

@@ -226,7 +226,7 @@ var LibraryDylink = {
         dbg(`updateGOT: before: ${symName} : ${GOT[symName].value}`);
 #endif
         if (typeof value == 'function') {
-          GOT[symName].value = {{{ to64('addFunction(value)') }}};
+          GOT[symName].value = {{{ idxToPtr('addFunction(value)') }}};
 #if DYLINK_DEBUG == 2
           dbg(`updateGOT: FUNC: ${symName} : ${GOT[symName].value}`);
 #endif
@@ -272,7 +272,7 @@ var LibraryDylink = {
         value = value.value;
       }
       if (typeof value == {{{ POINTER_JS_TYPE }}}) {
-        value += {{{ to64('memoryBase') }}};
+        value += {{{ idxToPtr('memoryBase') }}};
       }
       relocated[e] = value;
     }
@@ -304,12 +304,12 @@ var LibraryDylink = {
 #endif
         if (typeof value == 'function') {
           /** @suppress {checkTypes} */
-          GOT[symName].value = {{{ to64('addFunction(value, value.sig)') }}};
+          GOT[symName].value = {{{ idxToPtr('addFunction(value, value.sig)') }}};
 #if DYLINK_DEBUG == 2
           dbg(`assigning table entry for : ${symName} -> ${GOT[symName].value}`);
 #endif
         } else if (typeof value == 'number') {
-          GOT[symName].value = {{{ to64('value') }}};
+          GOT[symName].value = {{{ idxToPtr('value') }}};
 #if MEMORY64
         } else if (typeof value == 'bigint') {
           GOT[symName].value = value;
@@ -381,7 +381,7 @@ var LibraryDylink = {
     assert(end <= HEAP8.length, 'failure to getMemory - memory growth etc. is not supported there, call malloc/sbrk directly or increase INITIAL_MEMORY');
 #endif
     ___heap_base = end;
-    GOT['__heap_base'].value = {{{ to64('end') }}};
+    GOT['__heap_base'].value = {{{ idxToPtr('end') }}};
     return ret;
   },
 
@@ -690,9 +690,9 @@ var LibraryDylink = {
           // symbols that should be local to this module
           switch (prop) {
             case '__memory_base':
-              return {{{ to64('memoryBase') }}};
+              return {{{ idxToPtr('memoryBase') }}};
             case '__table_base':
-              return {{{ to64('tableBase') }}};
+              return {{{ idxToPtr('tableBase') }}};
 #if MEMORY64
 #if MEMORY64 == 2
             case '__memory_base32':
@@ -755,7 +755,7 @@ var LibraryDylink = {
         // now.  Otherwise this is delayed until `setDylinkStackLimits` is
         // called after initialization.
         if (moduleExports['__set_stack_limits'] && runtimeInitialized) {
-          moduleExports['__set_stack_limits']({{{ to64('_emscripten_stack_get_base()') }}}, {{{ to64('_emscripten_stack_get_end()') }}});
+          moduleExports['__set_stack_limits']({{{ idxToPtr('_emscripten_stack_get_base()') }}}, {{{ idxToPtr('_emscripten_stack_get_end()') }}});
         }
 #endif
 
@@ -780,10 +780,8 @@ var LibraryDylink = {
 
         // Add any EM_ASM function that exist in the side module
         if ('__start_em_asm' in moduleExports) {
-          var start = moduleExports['__start_em_asm'];
-          var stop = moduleExports['__stop_em_asm'];
-          {{{ from64('start') }}}
-          {{{ from64('stop') }}}
+          var start = {{{ ptrToIdx('moduleExports["__start_em_asm"]') }}};
+          var stop = {{{ ptrToIdx('moduleExports["__stop_em_asm"]') }}};
           while (start < stop) {
             var jsString = UTF8ToString(start);
             addEmAsm(start, jsString);

src/library_glemu.js

@@ -399,7 +399,7 @@ var LibraryGLEmulation = {
                    (GL.currentContext.compressionExt ? ' GL_ARB_texture_compression GL_EXT_texture_compression_s3tc' : '') +
                    (GL.currentContext.anisotropicExt ? ' GL_EXT_texture_filter_anisotropic' : '')
             );
-            return GL.stringCache[name_] = {{{ to64('ret') }}};
+            return GL.stringCache[name_] = {{{ idxToPtr('ret') }}};
         }
         return glGetString(name_);
       };