Remove TextDecoderWrapper (#16448)

* Remove TextDecoderWrapper, and optimize performance of shared->unshared conversions via compile time analysis, and optimize generated code size.

* eslint

* Rebaseline test_minimal_runtime_code_size_hello_wasm_worker

Author: juj

src/parseTools.js

@@ -1205,3 +1205,23 @@ function runtimeKeepalivePop() {
   if (MINIMAL_RUNTIME || (EXIT_RUNTIME == 0 && USE_PTHREADS == 0)) return '';
   return 'runtimeKeepalivePop();';
 }
+
+// Some web functions like TextDecoder.decode() may not work with a view of a
+// SharedArrayBuffer, see https://github.com/whatwg/encoding/issues/172
+// To avoid that, this function allows obtaining an unshared copy of an
+// ArrayBuffer.
+function getUnsharedTextDecoderView(heap, start, end) {
+  const shared = `${heap}.slice(${start}, ${end})`;
+  const unshared = `${heap}.subarray(${start}, ${end})`;
+
+  // No need to worry about this in non-shared memory builds
+  if (!SHARED_MEMORY) return unshared;
+
+  // If asked to get an unshared view to what we know will be a shared view, or if in -Oz,
+  // then unconditionally do a .slice() for smallest code size.
+  if (SHRINK_LEVEL == 2 || heap == 'HEAPU8') return shared;
+
+  // Otherwise, generate a runtime type check: must do a .slice() if looking at a SAB,
+  // or can use .subarray() otherwise.
+  return `${heap}.buffer instanceof SharedArrayBuffer ? ${shared} : ${unshared}`;
+}

src/runtime_strings.js

@@ -6,38 +6,14 @@
 
 // runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.
 
-// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
-// a copy of that string as a Javascript String object.
-
-#if SHARED_MEMORY && TEXTDECODER
-/**
- * UTF8Decoder.decode may not work with a view of a SharedArrayBuffer, see
- * https://github.com/whatwg/encoding/issues/172
- * To avoid that, we wrap around it and add a copy into a normal ArrayBuffer,
- * which can still be much faster than creating a string character by
- * character.
- * @constructor
- */
-function TextDecoderWrapper(encoding) {
-  var textDecoder = new TextDecoder(encoding);
-  this.decode = (data) => {
-#if ASSERTIONS
-    assert(data instanceof Uint8Array);
-#endif
-    // While we compile with pthreads, this method can be called on side buffers
-    // as well, such as the stdout buffer in the filesystem code. Only copy when
-    // we have to.
-    return textDecoder.decode(data.buffer instanceof SharedArrayBuffer ? new Uint8Array(data) : data);
-  };
-}
-#endif
-
 #if TEXTDECODER == 2
-var UTF8Decoder = new TextDecoder{{{ SHARED_MEMORY ? 'Wrapper' : ''}}}('utf8');
+var UTF8Decoder = new TextDecoder('utf8');
 #elif TEXTDECODER == 1
-var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder{{{ SHARED_MEMORY ? 'Wrapper' : ''}}}('utf8') : undefined;
+var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
 #endif
 
+// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
+// a copy of that string as a Javascript String object.
 /**
  * heapOrArray is either a regular array, or a JavaScript typed array view.
  * @param {number} idx
@@ -58,11 +34,11 @@ function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
 #endif // TEXTDECODER
 
 #if TEXTDECODER == 2
-  return UTF8Decoder.decode(heapOrArray.buffer ? heapOrArray.subarray(idx, endPtr) : new Uint8Array(heapOrArray.slice(idx, endPtr)));
+  return UTF8Decoder.decode(heapOrArray.buffer ? {{{ getUnsharedTextDecoderView('heapOrArray', 'idx', 'endPtr') }}} : new Uint8Array(heapOrArray.slice(idx, endPtr)));
 #else // TEXTDECODER == 2
 #if TEXTDECODER
   if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-    return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+    return UTF8Decoder.decode({{{ getUnsharedTextDecoderView('heapOrArray', 'idx', 'endPtr') }}});
   } else {
 #endif // TEXTDECODER
     var str = '';
@@ -133,7 +109,7 @@ function UTF8ToString(ptr, maxBytesToRead) {
   if (!ptr) return '';
   var maxPtr = ptr + maxBytesToRead;
   for (var end = ptr; !(end >= maxPtr) && HEAPU8[end];) ++end;
-  return UTF8Decoder.decode(HEAPU8.subarray(ptr, end));
+  return UTF8Decoder.decode({{{ getUnsharedTextDecoderView('HEAPU8', 'ptr', 'end') }}});
 #else
   return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
 #endif

src/runtime_strings_extra.js

@@ -32,9 +32,9 @@ function stringToAscii(str, outPtr) {
 // a copy of that string as a Javascript String object.
 
 #if TEXTDECODER == 2
-var UTF16Decoder = new TextDecoder{{{ SHARED_MEMORY ? 'Wrapper' : ''}}}('utf-16le');
+var UTF16Decoder = new TextDecoder('utf-16le');
 #elif TEXTDECODER == 1
-var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder{{{ SHARED_MEMORY ? 'Wrapper' : ''}}}('utf-16le') : undefined;
+var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;
 #endif
 
 function UTF16ToString(ptr, maxBytesToRead) {
@@ -55,7 +55,7 @@ function UTF16ToString(ptr, maxBytesToRead) {
 #if TEXTDECODER != 2
   if (endPtr - ptr > 32 && UTF16Decoder) {
 #endif // TEXTDECODER != 2
-    return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+    return UTF16Decoder.decode({{{ getUnsharedTextDecoderView('HEAPU8', 'ptr', 'endPtr') }}});
 #if TEXTDECODER != 2
   } else {
 #endif // TEXTDECODER != 2

tests/code_size/hello_wasm_worker_wasm.js

@@ -1,12 +1,6 @@
 var b = Module;
 
-var c = b.$ww;
-
-new function(a) {
-    new TextDecoder(a);
-}("utf8");
-
-var e, f;
+var c = b.$ww, e, f;
 
 e = b.mem || new WebAssembly.Memory({
     initial: 256,

tests/code_size/hello_wasm_worker_wasm.json

@@ -1,10 +1,10 @@
 {
   "a.html": 737,
   "a.html.gz": 433,
-  "a.js": 813,
-  "a.js.gz": 501,
+  "a.js": 765,
+  "a.js.gz": 475,
   "a.wasm": 1792,
   "a.wasm.gz": 989,
-  "total": 3342,
-  "total_gz": 1923
+  "total": 3294,
+  "total_gz": 1897
 }