buffer: use simdutf convert_latin1_to_utf8_safe

simdutf 5.5 includes convert_latin1_to_utf8_safe

fuzz/buffer-write.js

@@ -0,0 +1,45 @@
+const assert = require('node:assert')
+const crypto = require('node:crypto')
+
+for (let i = 0; i < 1e6; i++) {
+  const len = Math.floor(Math.random() * 128)
+  const buf = Buffer.allocUnsafe(len)
+  crypto.getRandomValues(buf)
+
+  for (let n = 0; n < 16; n++) {
+    const start = Math.floor(Math.random() * len)
+    const end = Math.min(len, start + Math.floor(Math.random() * (len - start)))
+    const src = buf.subarray(start, end)
+    const str = src.toString('utf8')
+
+    let bufNew = Buffer.alloc(buf.length);
+    let bufOld = Buffer.alloc(buf.length);
+
+    bufNew = bufNew.subarray(0, bufNew.utf8Write(str, start))
+    bufOld = bufOld.subarray(0, bufOld.utf8WriteLegacy(str, start))
+
+    try {
+      assert.deepStrictEqual(bufNew, bufOld)
+    } catch (err) {
+      console.error({
+        start,
+        src: new Uint8Array(src),
+        bufNew: {
+          byteOffset: bufNew.byteOffset,
+          byteLength: bufNew.byteLength,
+          buffer: {
+            byteLength: bufNew.buffer.byteLength
+          }
+        },
+        bufOld: {
+          byteOffset: bufOld.byteOffset,
+          byteLength: bufOld.byteLength,
+          buffer: {
+            byteLength: bufOld.buffer.byteLength
+          }
+        }
+      })
+      throw err
+    }
+  }
+}

src/node_buffer.cc

@@ -1443,58 +1443,6 @@ void CopyArrayBuffer(const FunctionCallbackInfo<Value>& args) {
   memcpy(dest, src, bytes_to_copy);
 }
 
-size_t convert_latin1_to_utf8_s(const char* src,
-                                size_t src_len,
-                                char* dst,
-                                size_t dst_len) noexcept {
-  size_t src_pos = 0;
-  size_t dst_pos = 0;
-
-  const auto safe_len = std::min(src_len, dst_len >> 1);
-  if (safe_len > 16) {
-    // convert_latin1_to_utf8 will never write more than input length * 2.
-    dst_pos += simdutf::convert_latin1_to_utf8(src, safe_len, dst);
-    src_pos += safe_len;
-  }
-
-  // Based on:
-  // https://github.com/simdutf/simdutf/blob/master/src/scalar/latin1_to_utf8/latin1_to_utf8.h
-  // with an upper limit on the number of bytes to write.
-
-  const auto src_ptr = reinterpret_cast<const uint8_t*>(src);
-  const auto dst_ptr = reinterpret_cast<uint8_t*>(dst);
-
-  size_t skip_pos = src_pos;
-  while (src_pos < src_len && dst_pos < dst_len) {
-    if (skip_pos <= src_pos && src_pos + 16 <= src_len &&
-        dst_pos + 16 <= dst_len) {
-      uint64_t v1;
-      memcpy(&v1, src_ptr + src_pos + 0, 8);
-      uint64_t v2;
-      memcpy(&v2, src_ptr + src_pos + 8, 8);
-      if (((v1 | v2) & UINT64_C(0x8080808080808080)) == 0) {
-        memcpy(dst_ptr + dst_pos, src_ptr + src_pos, 16);
-        dst_pos += 16;
-        src_pos += 16;
-      } else {
-        skip_pos = src_pos + 16;
-      }
-    } else {
-      const auto byte = src_ptr[src_pos++];
-      if ((byte & 0x80) == 0) {
-        dst_ptr[dst_pos++] = byte;
-      } else if (dst_pos + 2 <= dst_len) {
-        dst_ptr[dst_pos++] = (byte >> 6) | 0b11000000;
-        dst_ptr[dst_pos++] = (byte & 0b111111) | 0b10000000;
-      } else {
-        break;
-      }
-    }
-  }
-
-  return dst_pos;
-}
-
 template <encoding encoding>
 uint32_t WriteOneByteString(const char* src,
                             uint32_t src_len,
@@ -1505,7 +1453,7 @@ uint32_t WriteOneByteString(const char* src,
   }
 
   if (encoding == UTF8) {
-    return convert_latin1_to_utf8_s(src, src_len, dst, dst_len);
+    return simdutf::convert_latin1_to_utf8_safe(src, src_len, dst, dst_len);
   } else if (encoding == LATIN1 || encoding == ASCII) {
     const auto size = std::min(src_len, dst_len);
     memcpy(dst, src, size);