Merge branch 'main' into shared_memory

Author: eyebrowsoffire

ChangeLog.md

@@ -23,6 +23,13 @@ See docs/process.md for more on how version tagging works.
 - The usage of `EM_BOOL` in the emscripten API has been replaced with C/C++
   bool.  This change should not be observable since `EM_BOOL` has been
   equivalent to `bool` since #22157. (#22155)
+- Fix regression introduced in 3.1.67 (#22557) which broke webgpu / int64
+  integration. (#22689)
+- SDL2 port updated from 2.28.4 to 2.30.8. (#22697)
+- embind no longer exports any library functions by default.  Previously we
+  would export getInheritedInstanceCount, getLiveInheritedInstances,
+  flushPendingDeletes and setDelayFunction.  If you need these library function
+  exprted they can be added to `EXPORTED_RUNTIME_METHODS`. (#22705)
 
 3.1.68 - 09/30/24
 -----------------

site/source/docs/api_reference/wasm_audio_worklets.rst

@@ -126,8 +126,7 @@ which resumes the audio context when the user clicks on the DOM Canvas element t
                                                               "noise-generator", &options, &GenerateNoise, 0);
 
     // Connect it to audio context destination
-    EM_ASM({emscriptenGetAudioObject($0).connect(emscriptenGetAudioObject($1).destination)},
-      wasmAudioWorklet, audioContext);
+    emscripten_audio_node_connect(wasmAudioWorklet, audioContext, 0, 0);
 
     // Resume context on mouse click
     emscripten_set_click_callback("canvas", (void*)audioContext, 0, OnCanvasClick);

site/source/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.rst

@@ -613,30 +613,63 @@ Calling JavaScript functions as function pointers from C
 ========================================================
 
 You can use ``addFunction`` to return an integer value that represents a
-function pointer. Passing that integer to C code then lets it call that value as
-a function pointer, and the JavaScript function you sent to ``addFunction`` will
-be called.
+function pointer. Passing that integer to C code then lets it call that value
+as a function pointer, and the JavaScript function you sent to ``addFunction``
+will be called.
 
 See `test_add_function in test/test_core.py`_ for an example.
 
 You should build with ``-sALLOW_TABLE_GROWTH`` to allow new functions to be
 added to the table. Otherwise by default the table has a fixed size.
 
-.. note:: When using ``addFunction`` on LLVM Wasm backend, you need to provide
-   an additional second argument, a Wasm function signature string. Each
-   character within a signature string represents a type. The first character
-   represents the return type of a function, and remaining characters are for
-   parameter types.
+When using ``addFunction`` with a JavaScript function, you need to provide
+an additional second argument, a Wasm function signature string, explained
+below. See `test/interop/test_add_function_post.js <https://github.com/emscripten-core/emscripten/blob/main/test/interop/test_add_function_post.js>`_ for an example.
+
+
+.. _interacting-with-code-function-signatures:
+
+Function Signatures
+===================
+
+The LLVM Wasm backend requires a Wasm function signature string when using
+``addFunction`` and in JavaScript libraries. Each character within a signature
+string represents a type. The first character represents the return type of a
+function, and remaining characters are for parameter types.
 
    - ``'v'``: void type
    - ``'i'``: 32-bit integer type
-   - ``'j'``: 64-bit integer type (currently does not exist in JavaScript)
+   - ``'j'``: 64-bit integer type (see note below)
    - ``'f'``: 32-bit float type
    - ``'d'``: 64-bit float type
+   - ``'p'``: 32-bit or 64-bit pointer (MEMORY64)
+
+For example, if you add a function that takes an integer and does not return
+anything, the signature is ``'vi'``.
+
+When ``'j'`` is used there are several ways in which the parameter value will
+be passed to JavaScript. By default, the value will either be passed as a
+single BigInt or a pair of JavaScript numbers (double) depending on whether
+the ``WASM_BIGINT`` settings is enabled. In addition, if you only require 53
+bits of precision you can add the ``__i53abi`` decorator, which will ignore
+the upper bits and the value will be received as a single JavaScript number
+(double).  It cannot be used with ``addFunction``.  Here is an example of a
+library function that sets the size of a file using a 64-bit value passed as
+a 53 bit (double) and returns an integer error code:
+
+.. code-block:: c
+
+  extern "C" int _set_file_size(int handle, uint64_t size);
+
+.. code-block:: javascript
 
-   For example, if you add a function that takes an integer and does not return
-   anything, you can do ``addFunction(your_function, 'vi');``. See
-   `test/interop/test_add_function_post.js <https://github.com/emscripten-core/emscripten/blob/main/test/interop/test_add_function_post.js>`_ for an example.
+  _set_file_size__i53abi: true,  // Handle 64-bit 
+  _set_file_size__sig: 'iij',    // Function signature
+  _set_file_size: function(handle, size) { ... return error; }
+    
+Using ``-sWASM_BIGINT`` when linking is an alternative method of handling
+64-bit types in libraries.  ```Number()``` may be needed on the JavaScript
+side to convert it to a useable value.  See `settings reference <https://emscripten.org/docs/tools_reference/settings_reference.html?highlight=environment#wasm-bigint>`_.
 
 
 .. _interacting-with-code-access-memory:

site/source/docs/porting/connecting_cpp_and_javascript/embind.rst

@@ -1078,7 +1078,7 @@ For convenience, *embind* provides factory functions to register
     EMSCRIPTEN_BINDINGS(stl_wrappers) {
         register_vector<int>("VectorInt");
         register_map<int,int>("MapIntInt");
-        register_optional<std::string>("Optional");
+        register_optional<std::string>();
     }
 
 A full example is shown below:

src/closure-externs/node-externs.js

@@ -104,3 +104,18 @@ Buffer.prototype.toString = function(encoding, start, end) {};
 
 Worker.prototype.ref = function() {};
 Worker.prototype.unref = function() {};
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.atimeMs;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.mtimeMs;
+
+/**
+ * @type {number}
+ */
+fs.Stats.prototype.ctimeMs;

src/embind/embind.js

@@ -59,16 +59,6 @@ var LibraryEmbind = {
   }`,
   $EmValOptionalType__deps: ['$EmValType'],
   $EmValOptionalType: '=Object.assign({optional: true}, EmValType);',
-  $init_embind__deps: [
-    '$getInheritedInstanceCount', '$getLiveInheritedInstances',
-    '$flushPendingDeletes', '$setDelayFunction'],
-  $init_embind__postset: 'init_embind();',
-  $init_embind: () => {
-    Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
-    Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
-    Module['flushPendingDeletes'] = flushPendingDeletes;
-    Module['setDelayFunction'] = setDelayFunction;
-  },
 
   $throwUnboundTypeError__deps: ['$registeredTypes', '$typeDependencies', '$UnboundTypeError', '$getTypeName'],
   $throwUnboundTypeError: (message, types) => {
@@ -219,7 +209,6 @@ var LibraryEmbind = {
   },
 
   // raw pointer -> instance
-  $registeredInstances__deps: ['$init_embind'],
   $registeredInstances: {},
 
   $getBasestPointer__deps: ['$throwBindingError'],
@@ -1582,6 +1571,8 @@ var LibraryEmbind = {
     '$releaseClassHandle',
     '$throwBindingError',
     '$detachFinalizer',
+    '$flushPendingDeletes',
+    '$delayFunction',
   ],
   $init_ClassHandle: () => {
     Object.assign(ClassHandle.prototype, {

src/library.js

@@ -1534,7 +1534,7 @@ addToLibrary({
   emscripten_log__deps: ['$formatString', '$emscriptenLog'],
   emscripten_log: (flags, format, varargs) => {
     var result = formatString(format, varargs);
-    var str = UTF8ArrayToString(result, 0);
+    var str = UTF8ArrayToString(result);
     emscriptenLog(flags, str);
   },
 

src/library_fs.js

@@ -1303,7 +1303,7 @@ FS.staticInit();
       var buf = new Uint8Array(length);
       FS.read(stream, buf, 0, length, 0);
       if (opts.encoding === 'utf8') {
-        ret = UTF8ArrayToString(buf, 0);
+        ret = UTF8ArrayToString(buf);
       } else if (opts.encoding === 'binary') {
         ret = buf;
       }

src/library_noderawfs.js

@@ -91,7 +91,17 @@ addToLibrary({
       var stream = FS.getStreamChecked(fd);
       fs.ftruncateSync(stream.nfd, len);
     },
-    utime(path, atime, mtime) { fs.utimesSync(path, atime/1000, mtime/1000); },
+    utime(path, atime, mtime) {
+      // -1 here for atime or mtime means UTIME_OMIT was passed.  Since node
+      // doesn't support this concept we need to first find the existing
+      // timestamps in order to preserve them.
+      if (atime == -1 || mtime == -1) {
+        var st = fs.statSync(path);
+        if (atime == -1) atime = st.atimeMs;
+        if (mtime == -1) mtime = st.mtimeMs;
+      }
+      fs.utimesSync(path, atime/1000, mtime/1000);
+    },
     open(path, flags, mode) {
       if (typeof flags == "string") {
         flags = FS_modeStringToFlags(flags)

src/library_pthread.js

@@ -405,7 +405,11 @@ var LibraryPThread = {
 #if ENVIRONMENT_MAY_BE_WEB || ENVIRONMENT_MAY_BE_WORKER
         // This is the way that we signal to the Web Worker that it is hosting
         // a pthread.
+#if ASSERTIONS
+        'name': 'em-pthread-' + PThread.nextWorkerID,
+#else
         'name': 'em-pthread',
+#endif
 #endif
       };
 #if EXPORT_ES6 && USE_ES6_IMPORT_META