[Wasm64] More embind fixes. (#17332)

Enough to make two more tests pass:

- test_embind_val
- test_embind_dynamic_initialization

Author: sbc100

src/embind/embind.js

@@ -629,7 +629,7 @@ var LibraryEmbind = {
             return value;
         },
         'toWireType': function (destructors, value) {
-            if (typeof value != "bigint") {
+            if (typeof value != "bigint" && typeof value != "number") {
                 throw new TypeError('Cannot convert "' + embindRepr(value) + '" to ' + this.name);
             }
             if (value < minRange || value > maxRange) {
@@ -678,7 +678,7 @@ var LibraryEmbind = {
 
   // For types whose wire types are 32-bit pointers.
   $simpleReadValueFromPointer: function(pointer) {
-    return this['fromWireType'](HEAPU32[pointer >> 2]);
+    return this['fromWireType']({{{ makeGetValue('pointer', '0', 'i32') }}});
   },
 
   _embind_register_std_string__sig: 'vpp',
@@ -698,14 +698,15 @@ var LibraryEmbind = {
     registerType(rawType, {
         name: name,
         'fromWireType': function(value) {
-            var length = HEAPU32[value >> 2];
+            var length = {{{ makeGetValue('value', '0', SIZE_TYPE) }}};
+            var payload = value + {{{ POINTER_SIZE }}};
 
             var str;
             if (stdStringIsUTF8) {
-                var decodeStartPtr = value + 4;
+                var decodeStartPtr = payload;
                 // Looping here to support possible embedded '0' bytes
                 for (var i = 0; i <= length; ++i) {
-                    var currentBytePtr = value + 4 + i;
+                    var currentBytePtr = payload + i;
                     if (i == length || HEAPU8[currentBytePtr] == 0) {
                         var maxRead = currentBytePtr - decodeStartPtr;
                         var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
@@ -721,7 +722,7 @@ var LibraryEmbind = {
             } else {
                 var a = new Array(length);
                 for (var i = 0; i < length; ++i) {
-                    a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
+                    a[i] = String.fromCharCode(HEAPU8[payload + i]);
                 }
                 str = a.join('');
             }
@@ -748,13 +749,14 @@ var LibraryEmbind = {
             }
 
             // assumes 4-byte alignment
-            var ptr = _malloc(4 + length + 1);
+            var base = _malloc({{{ POINTER_SIZE }}} + length + 1);
+            var ptr = base + {{{ POINTER_SIZE }}};
 #if CAN_ADDRESS_2GB
             ptr >>>= 0;
 #endif
-            HEAPU32[ptr >> 2] = length;
+            {{{ makeSetValue('base', '0', 'length', SIZE_TYPE) }}};
             if (stdStringIsUTF8 && valueIsOfTypeString) {
-                stringToUTF8(value, ptr + 4, length + 1);
+                stringToUTF8(value, ptr, length + 1);
             } else {
                 if (valueIsOfTypeString) {
                     for (var i = 0; i < length; ++i) {
@@ -763,19 +765,19 @@ var LibraryEmbind = {
                             _free(ptr);
                             throwBindingError('String has UTF-16 code units that do not fit in 8 bits');
                         }
-                        HEAPU8[ptr + 4 + i] = charCode;
+                        HEAPU8[ptr + i] = charCode;
                     }
                 } else {
                     for (var i = 0; i < length; ++i) {
-                        HEAPU8[ptr + 4 + i] = value[i];
+                        HEAPU8[ptr + i] = value[i];
                     }
                 }
             }
 
             if (destructors !== null) {
-                destructors.push(_free, ptr);
+                destructors.push(_free, base);
             }
-            return ptr;
+            return base;
         },
         'argPackAdvance': 8,
         'readValueFromPointer': simpleReadValueFromPointer,
@@ -1658,9 +1660,19 @@ var LibraryEmbind = {
 
   $RegisteredPointer_fromWireType__deps: [
     '$downcastPointer', '$registeredPointers',
-    '$getInheritedInstance', '$makeClassHandle'],
+    '$getInheritedInstance', '$makeClassHandle',
+#if MEMORY64
+    '$bigintToI53Checked'
+#endif
+  ],
   $RegisteredPointer_fromWireType: function(ptr) {
     // ptr is a raw pointer (or a raw smartpointer)
+#if MEMORY64
+    ptr = bigintToI53Checked(ptr);
+#if ASSERTIONS
+    assert(ptr != NaN);
+#endif
+#endif
 
     // rawPointer is a maybe-null raw pointer
     var rawPointer = this.getPointee(ptr);

src/embind/emval.js

@@ -153,9 +153,9 @@ var LibraryEmVal = {
 
   _emval_take_value__sig: 'ppp',
   _emval_take_value__deps: ['$Emval', '$requireRegisteredType'],
-  _emval_take_value: function(type, argv) {
+  _emval_take_value: function(type, arg) {
     type = requireRegisteredType(type, '_emval_take_value');
-    var v = type['readValueFromPointer'](argv);
+    var v = type['readValueFromPointer'](arg);
     return Emval.toHandle(v);
   },
 

src/jsifier.js

@@ -101,13 +101,15 @@ function runJSify(functionsOnly) {
     // 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 argLines = args.split('\n');
+      argLines = argLines.map((line) => line.split('//')[0]);
+      const argNames = argLines.join(' ').split(',').map((name) => name.trim());
       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`;
+          argConvertions += `  ${name} = Number(${name});\n`;
           newArgs.push(`Number(${name})`);
         } else {
           newArgs.push(name);
@@ -130,7 +132,7 @@ function ${name}(${args}) {
       // before executing the function body.
       return `\
 function ${name}(${args}) {
-  ${argConvertions};
+${argConvertions}
   ${body};
 }`;
     });

src/library.js

@@ -167,6 +167,7 @@ mergeInto(LibraryManager.library, {
     '$emscripten_realloc_buffer',
 #endif
   ],
+  emscripten_resize_heap: 'ip',
   emscripten_resize_heap: function(requestedSize) {
     var oldSize = HEAPU8.length;
     requestedSize = requestedSize >>> 0;

tests/test_core.py

@@ -7442,7 +7442,6 @@ def test_embind_unsigned(self):
     self.emcc_args += ['-lembind']
     self.do_run_in_out_file_test('embind/test_unsigned.cpp')
 
-  @no_wasm64('embind does not yet support MEMORY64')
   def test_embind_val(self):
     self.emcc_args += ['-lembind']
     self.do_run_in_out_file_test('embind/test_val.cpp')
@@ -7451,7 +7450,6 @@ def test_embind_val_assignment(self):
     err = self.expect_fail([EMCC, test_file('embind/test_val_assignment.cpp'), '-lembind', '-c'])
     self.assertContained('candidate function not viable: expects an lvalue for object argument', err)
 
-  @no_wasm64('embind does not yet support MEMORY64')
   def test_embind_dynamic_initialization(self):
     self.emcc_args += ['-lembind']
     self.do_run_in_out_file_test('embind/test_dynamic_initialization.cpp')