[embind] Fix transferring size_t when memory64 is enabled. (#25896)

When passing a `size_t` to `val` in memory64 mode, the top 32 bits were
being truncated. This happened since `size_t` did not match the
ovlerloads for `writeGenericWireType` and instead used the generic
overload that wrote the value to a 32bit unsigned number.

Fixes #25859

Author: brendandahl

system/include/emscripten/val.h

@@ -210,6 +210,12 @@ inline void writeGenericWireType(GenericWireType*& cursor, uint64_t wt) {
   ++cursor;
 }
 
+// Explicit overload for size_t to prevent fallback to the 32-bit generic template
+inline void writeGenericWireType(GenericWireType*& cursor, std::size_t wt) {
+  cursor->w[0].s = wt; // Uses the size_t member (64-bit in Memory64)
+  ++cursor;
+}
+
 template<typename T>
 void writeGenericWireType(GenericWireType*& cursor, T* wt) {
   cursor->w[0].p = wt;
@@ -225,6 +231,7 @@ inline void writeGenericWireType(GenericWireType*& cursor, const memory_view<Ele
 
 template<typename T>
 void writeGenericWireType(GenericWireType*& cursor, T wt) {
+  static_assert(sizeof(T) <= sizeof(cursor->w[0].u), "Generic wire type must be smaller than unsigned.");
   cursor->w[0].u = static_cast<unsigned>(wt);
   ++cursor;
 }

test/embind/test_i64_val.cpp

@@ -27,30 +27,42 @@ void ensure_js(string js_code) {
 }
 
 template <typename T>
-string compare_a_64_js(T value) {
+string compare_a_number_or_bigint_js(T value) {
+  static_assert(sizeof(T) == 8 || sizeof(T) == 4);
   stringstream ss;
-  ss << "a === " << value << "n";
+  ss << "a === " << value;
+  if constexpr (sizeof(T) == 8) {
+    ss << "n";
+  }
   return ss.str();
 }
 
 template <typename T>
 void test_value(T value) {
+  static_assert(sizeof(T) == 8 || sizeof(T) == 4);
   cout << "  testing value " << value << endl;
   cout << "    setting properties preserves the expected value" << endl;
   val::global().set("a", val(value));
-  ensure_js(compare_a_64_js(value));
+  ensure_js(compare_a_number_or_bigint_js(value));
   cout << "    getting properties returns the original value intact" << endl;
   assert(val::global()["a"].as<T>() == value);
   cout << "    function calls roundtrip the value correctly" << endl;
-  assert(val::global("BigInt")(value).template as<T>() == value);
+  const char* typeName;
+  if constexpr (sizeof(T) == 8) {
+    typeName = "BigInt";
+  } else {
+    typeName = "Number";
+  }
+  assert(val::global(typeName)(value).template as<T>() == value);
   cout << "    method calls roundtrip the value correctly" << endl;
-  assert(val::global().call<T>("BigInt", value) == value);
+  assert(val::global().call<T>(typeName, value) == value);
 }
 
 int main() {
   const int64_t max_int64_t = numeric_limits<int64_t>::max();
   const int64_t min_int64_t = numeric_limits<int64_t>::min();
   const uint64_t max_uint64_t = numeric_limits<uint64_t>::max();
+  const size_t max_size_t = std::numeric_limits<size_t>::max();
   std::array<std::uint64_t, 5> uint64Array = {0, 1, 2, 3, 4};
   std::array<std::int64_t, 5> int64Array = {-2, -1, 0, 1, 2};
 
@@ -68,6 +80,10 @@ int main() {
   test_value(min_int64_t);
   test_value(max_int64_t);
 
+  test("val(size_t v)");
+  test_value(size_t(1234));
+  test_value(max_size_t);
+
   test("val(typed_memory_view<uint64_t>)");
   val::global().set("a", val(typed_memory_view(uint64Array.size(), uint64Array.data())));
   ensure_js("a instanceof BigUint64Array");

test/embind/test_i64_val.out

@@ -39,6 +39,18 @@ val(int64_t v)
     function calls roundtrip the value correctly
     method calls roundtrip the value correctly
 test:
+val(size_t v)
+  testing value 1234
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value 4294967295
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+test:
 val(typed_memory_view<uint64_t>)
 test:
 val(typed_memory_view<int64_t>)

test/embind/test_i64_val64.out

@@ -0,0 +1,57 @@
+start
+test:
+val(uint64_t v)
+  testing value 1234
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value 18446744073709551615
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+test:
+val(int64_t v)
+  testing value 1234
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value -4321
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value 1311768467732155613
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value -9223372036854775808
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value 9223372036854775807
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+test:
+val(size_t v)
+  testing value 1234
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+  testing value 18446744073709551615
+    setting properties preserves the expected value
+    getting properties returns the original value intact
+    function calls roundtrip the value correctly
+    method calls roundtrip the value correctly
+test:
+val(typed_memory_view<uint64_t>)
+test:
+val(typed_memory_view<int64_t>)
+end

test/test_core.py

@@ -7721,7 +7721,8 @@ def test_embind_i64_val(self, safe_heap):
       self.skipTest('asan does not work with SAFE_HEAP')
     self.set_setting('SAFE_HEAP', safe_heap)
     self.cflags += ['-lembind']
-    self.do_run_in_out_file_test('embind/test_i64_val.cpp', assert_identical=True)
+    out_suffix = '64' if self.get_setting('MEMORY64') else ''
+    self.do_run_in_out_file_test('embind/test_i64_val.cpp', assert_identical=True, out_suffix=out_suffix)
 
   @no_wasm2js('wasm_bigint')
   def test_embind_i64_binding(self):