Always use bulkmemory memcpy and memset when available

Unlike the JS versions of these function there is no need to only use
these for small inputs.

Results of running the test_memcpy_128b test before and after this
change:

```
v8-bulk: mean: 1.536 (+-0.071) secs  median: 1.495  range: 1.471-1.650  (noise: 4.630%)  (5 runs)
        size:   149291, compressed:    54249
```

->

```
v8-bulk: mean: 1.489 (+-0.117) secs  median: 1.535  range: 1.268-1.606  (noise: 7.871%)  (5 runs)-
        size:   148387, compressed:    53813-
```

See comments in #19128

Author: sbc100

src/library.js

@@ -385,8 +385,8 @@ addToLibrary({
   $ENV: {},
 
   // In -Oz builds, we replace memcpy() altogether with a non-unrolled wasm
-  // variant, so we should never emit emscripten_memcpy_big() in the build.
-  // In STANDALONE_WASM we avoid the emscripten_memcpy_big dependency so keep
+  // variant, so we should never emit emscripten_memcpy_js() in the build.
+  // In STANDALONE_WASM we avoid the emscripten_memcpy_js dependency so keep
   // the wasm file standalone.
   // In BULK_MEMORY mode we include native versions of these functions based
   // on memory.fill and memory.copy.
@@ -407,11 +407,11 @@ addToLibrary({
   //   AppleWebKit/605.1.15 Safari/604.1 Version/13.0.4 iPhone OS 13_3 on iPhone 6s with iOS 13.3
   //   AppleWebKit/605.1.15 Version/13.0.3 Intel Mac OS X 10_15_1 on Safari 13.0.3 (15608.3.10.1.4) on macOS Catalina 10.15.1
   // Hence the support status of .copyWithin() for Safari version range [10.0.0, 10.1.0] is unknown.
-  emscripten_memcpy_big: `= Uint8Array.prototype.copyWithin
+  emscripten_memcpy_js: `= Uint8Array.prototype.copyWithin
     ? (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num)
     : (dest, src, num) => HEAPU8.set(HEAPU8.subarray(src, src+num), dest)`,
 #else
-  emscripten_memcpy_big: (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num),
+  emscripten_memcpy_js: (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num),
 #endif
 
 #endif

system/lib/libc/emscripten_internal.h

@@ -28,10 +28,14 @@ extern "C" {
 
 // An external JS implementation that is efficient for very large copies, using
 // HEAPU8.set()
-void emscripten_memcpy_big(void* __restrict__ dest,
+void emscripten_memcpy_js(void* __restrict__ dest,
                            const void* __restrict__ src,
-                           size_t n) EM_IMPORT(emscripten_memcpy_big);
-void emscripten_memset_big(void* ptr, char value, size_t n);
+                           size_t n) EM_IMPORT(emscripten_memcpy_js);
+
+void* emscripten_memcpy_bulkmem(void* __restrict__ dest,
+                                const void* __restrict__ src,
+                                size_t n);
+void* emscripten_memset_bulkmem(void* ptr, char value, size_t n);
 
 void emscripten_notify_memory_growth(size_t memory_index);
 

system/lib/libc/emscripten_memcpy.c

@@ -19,6 +19,12 @@ static void *__memcpy(void *dest, const void *src, size_t n) {
   return dest;
 }
 
+#elif defined(__wasm_bulk_memory__)
+
+static void *__memcpy(void *restrict dest, const void *restrict src, size_t n) {
+  return emscripten_memcpy_bulkmem(dest, src, n);
+}
+
 #else
 
 static void *__memcpy(void *restrict dest, const void *restrict src, size_t n) {
@@ -29,9 +35,9 @@ static void *__memcpy(void *restrict dest, const void *restrict src, size_t n) {
   unsigned char *block_aligned_d_end;
   unsigned char *d_end;
 
-#if !defined(EMSCRIPTEN_STANDALONE_WASM) || defined(__wasm_bulk_memory__)
+#if !defined(EMSCRIPTEN_STANDALONE_WASM)
   if (n >= 512) {
-    emscripten_memcpy_big(dest, src, n);
+    emscripten_memcpy_js(dest, src, n);
     return dest;
   }
 #endif

system/lib/libc/emscripten_memcpy_big.S renamed to system/lib/libc/emscripten_memcpy_bulkmem.S

@@ -4,11 +4,12 @@
 #define PTR i32
 #endif
 
-.globl emscripten_memcpy_big
-emscripten_memcpy_big:
-  .functype emscripten_memcpy_big (PTR, PTR, PTR) -> ()
+.globl emscripten_memcpy_bulkmem
+emscripten_memcpy_bulkmem:
+  .functype emscripten_memcpy_bulkmem (PTR, PTR, PTR) -> (PTR)
   local.get 0
   local.get 1
   local.get 2
   memory.copy 0, 0
+  local.get 0
   end_function

system/lib/libc/emscripten_memset.c

@@ -20,16 +20,8 @@ void *__memset(void *str, int c, size_t n) {
 
 #elif defined(__wasm_bulk_memory__)
 
-#define memset __musl_memset
-#include "musl/src/string/memset.c"
-#undef memset
-
 void *__memset(void *str, int c, size_t n) {
-  if (n >= 512) {
-    emscripten_memset_big(str, c, n);
-    return str;
-  }
-  return __musl_memset(str, c, n);
+  return emscripten_memset_bulkmem(str, c, n);
 }
 
 #else

system/lib/libc/emscripten_memset_big.S renamed to system/lib/libc/emscripten_memset_bulkmem.S

@@ -4,11 +4,12 @@
 #define PTR i32
 #endif
 
-.globl emscripten_memset_big
-emscripten_memset_big:
-  .functype emscripten_memset_big (PTR, i32, PTR) -> ()
+.globl emscripten_memset_bulkmem
+emscripten_memset_bulkmem:
+  .functype emscripten_memset_bulkmem (PTR, i32, PTR) -> (PTR)
   local.get 0
   local.get 1
   local.get 2
   memory.fill 0
+  local.get 0
   end_function

system/lib/standalone/standalone.c

@@ -142,11 +142,6 @@ weak int getentropy(void* buffer, size_t length) {
 
 // Emscripten additions
 
-// Should never be called in standalone mode
-weak void emscripten_memcpy_big(void *restrict dest, const void *restrict src, size_t n) {
-  __builtin_unreachable();
-}
-
 size_t emscripten_get_heap_max() {
   // In standalone mode we don't have any wasm instructions to access the max
   // memory size so the best we can do (without calling an import) is return

test/test_other.py

@@ -13486,11 +13486,11 @@ def run(args, expect_bulk_mem):
       funcs = self.parse_wasm('test_memops_bulk_memory.wasm')[2]
       js = read_file('test_memops_bulk_memory.js')
       if expect_bulk_mem:
-        self.assertNotContained('_emscripten_memcpy_big', js)
-        self.assertIn('$emscripten_memcpy_big', funcs)
+        self.assertNotContained('_emscripten_memcpy_js', js)
+        self.assertIn('$emscripten_memcpy_bulkmem', funcs)
       else:
-        self.assertContained('_emscripten_memcpy_big', js)
-        self.assertNotIn('$emscripten_memcpy_big', funcs)
+        self.assertContained('_emscripten_memcpy_js', js)
+        self.assertNotIn('$emscripten_memcpy_bulkmem', funcs)
 
     # By default we expect to find _emscripten_memcpy_big in the generaed JS and not in the
     # native code.

tools/system_libs.py

@@ -1315,7 +1315,7 @@ class libbulkmemory(MuslInternalLibrary, AsanInstrumentedLibrary):
   name = 'libbulkmemory'
   src_dir = 'system/lib/libc'
   src_files = ['emscripten_memcpy.c', 'emscripten_memset.c',
-               'emscripten_memcpy_big.S', 'emscripten_memset_big.S']
+               'emscripten_memcpy_bulkmem.S', 'emscripten_memset_bulkmem.S']
   cflags = ['-mbulk-memory']
 
   def can_use(self):