[corelib] Add rangeEquals to dart:typed_data

Implements native range equality comparison across all 9 integer
typed data lists (Uint8List, Int8List, Uint8ClampedList, Uint16List,
Int16List, Uint32List, Int32List, Uint64List, Int64List) and ByteData:

  bool rangeEquals(
      int start, int end, <SelfType> other, [int otherOffset = 0])

Float types (Float32List, Float64List, Float32x4List, Float64x2List)
are omitted to avoid discrepancies between IEEE-754 equality and
bitwise equality (such as NaN and -0.0).

- VM: lowered via native entry TypedDataBase_memEquals calling
  libc memcmp under NoSafepointScope, with pointer-equality fast path
  and element size assertions.
- JS (dart2js & DDC): inlines raw JS loop for NativeTypedArray, and
  32-bit chunking with Endian.little for NativeByteData, with fallback
  to List and ByteData methods for non-native implementations.
- Wasm: specializes per Wasm array type using direct array load
  instructions without bounds check overhead; 32-bit chunking for
  ByteData in both default and JS-compatibility modes.

R=lrn@google.com, vegorov@google.com

Fixes: #64095
TEST=tests/lib/typed_data/range_equals_test.dart
Change-Id: I132956aa9482d60d62f79bd891dddb84bb2bc456
TAG=agy
CONV=1e62e82d-deec-4edd-947d-b084183a5641
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/545160
Reviewed-by: Martin Kustermann <kustermann@google.com>
Reviewed-by: Stephen Adams <sra@google.com>
Reviewed-by: Lasse Nielsen <lrn@google.com>
Commit-Queue: Sigurd Meldgaard <sigurdm@google.com>
Reviewed-by: Slava Egorov <vegorov@google.com>

Author: sigurdm

CHANGELOG.md

@@ -14,6 +14,13 @@
 
 #### `dart:typed_data`
 
+- Added `rangeEquals` extension methods on all integer typed data lists
+  (`Uint8List`, `Int8List`, `Uint8ClampedList`, `Uint16List`, `Int16List`,
+  `Uint32List`, `Int32List`, `Uint64List`, `Int64List`) and `ByteData` for
+  efficient range equality comparisons.
+  For more details, see SDK issue [#64095][]
+
+[#64095]: https://github.com/dart-lang/sdk/issues/64095
 - Added the bit-wise negation operator `~` to `Int32x4`, which inverts every bit
   of every lane.
 - Added `Int32x4.splat`, which creates an `Int32x4` with the same 32-bit integer

runtime/lib/typed_data.cc

@@ -107,6 +107,55 @@ DEFINE_NATIVE_ENTRY(TypedDataBase_setClampedRange, 0, 5) {
   return Object::null();
 }
 
+DEFINE_NATIVE_ENTRY(TypedDataBase_memEquals, 0, 5) {
+  const TypedDataBase& a =
+      TypedDataBase::CheckedHandle(zone, arguments->NativeArgAt(0));
+  const Smi& a_start_smi = Smi::CheckedHandle(zone, arguments->NativeArgAt(1));
+  const TypedDataBase& b =
+      TypedDataBase::CheckedHandle(zone, arguments->NativeArgAt(2));
+  const Smi& b_start_smi = Smi::CheckedHandle(zone, arguments->NativeArgAt(3));
+  const Smi& count_smi = Smi::CheckedHandle(zone, arguments->NativeArgAt(4));
+
+  const intptr_t count = count_smi.Value();
+  if (count == 0) {
+    return Bool::True().ptr();
+  }
+
+  const intptr_t a_len = a.Length();
+  const intptr_t b_len = b.Length();
+  const intptr_t a_start = a_start_smi.Value();
+  const intptr_t b_start = b_start_smi.Value();
+  if (a_start < 0 || count < 0 || a_start > a_len - count) {
+    Exceptions::ThrowRangeError("aStart", a_start_smi, 0,
+                                a_len - count >= 0 ? a_len - count : 0);
+  }
+  if (b_start < 0 || b_start > b_len - count) {
+    Exceptions::ThrowRangeError("bStart", b_start_smi, 0,
+                                b_len - count >= 0 ? b_len - count : 0);
+  }
+
+  const intptr_t a_element_size = a.ElementSizeInBytes();
+  if (a_element_size != b.ElementSizeInBytes()) {
+    Exceptions::ThrowArgumentError(
+        String::Handle(String::New("Typed data element sizes do not match")));
+  }
+
+  const intptr_t a_start_in_bytes = a_start * a_element_size;
+  const intptr_t b_start_in_bytes = b_start * a_element_size;
+  const intptr_t length_in_bytes = count * a_element_size;
+
+  NoSafepointScope no_safepoint;
+  const void* a_data =
+      reinterpret_cast<const void*>(a.DataAddr(a_start_in_bytes));
+  const void* b_data =
+      reinterpret_cast<const void*>(b.DataAddr(b_start_in_bytes));
+  if (a_data == b_data) {
+    return Bool::True().ptr();
+  }
+
+  return Bool::Get(memcmp(a_data, b_data, length_in_bytes) == 0).ptr();
+}
+
 // The native getter and setter functions defined here are only called if
 // unboxing doubles or SIMD values is not supported by the flow graph compiler,
 // and the provided offsets have already been range checked by the calling code.

runtime/vm/bootstrap_natives.h

@@ -155,6 +155,7 @@ namespace dart {
   V(MicrotaskMirrorQueue_onAsyncCallbackComplete, 2)                           \
   V(TypedDataBase_length, 1)                                                   \
   V(TypedDataBase_setClampedRange, 5)                                          \
+  V(TypedDataBase_memEquals, 5)                                                \
   V(TypedData_GetFloat32, 2)                                                   \
   V(TypedData_SetFloat32, 3)                                                   \
   V(TypedData_GetFloat64, 2)                                                   \

sdk/lib/_internal/js_runtime/lib/typed_data_patch.dart

@@ -2,9 +2,9 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'dart:_foreign_helper' show JS;
 import 'dart:_internal' show patch;
 import 'dart:_native_typed_data';
-import "dart:_internal" show UnmodifiableListBase;
 
 @patch
 class ByteData {
@@ -193,3 +193,168 @@ class Float64x2 {
   @patch
   factory Float64x2.fromFloat32x4(Float32x4 v) = NativeFloat64x2.fromFloat32x4;
 }
+
+// Each integer typed array type has a dedicated, strictly monomorphic comparison
+// loop. This keeps V8's Inline Cache at `#[#] !== #[#]` strictly monomorphic
+// (IC size = 1), avoiding polymorphic/megamorphic transitions, deoptimizations,
+// and runtime type checks. Unused types can also be tree-shaken by dart2js.
+@patch
+@pragma('dart2js:prefer-inline')
+bool _uint8ListRangeEquals(
+  Uint8List a,
+  int aStart,
+  Uint8List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _int8ListRangeEquals(
+  Int8List a,
+  int aStart,
+  Int8List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _uint8ClampedListRangeEquals(
+  Uint8ClampedList a,
+  int aStart,
+  Uint8ClampedList b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _uint16ListRangeEquals(
+  Uint16List a,
+  int aStart,
+  Uint16List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _int16ListRangeEquals(
+  Int16List a,
+  int aStart,
+  Int16List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _uint32ListRangeEquals(
+  Uint32List a,
+  int aStart,
+  Uint32List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _int32ListRangeEquals(
+  Int32List a,
+  int aStart,
+  Int32List b,
+  int bStart,
+  int count,
+) {
+  for (int i = 0; i < count; i++) {
+    if (JS<bool>('bool', '#[#] !== #[#]', a, aStart + i, b, bStart + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+@patch
+@pragma('dart2js:prefer-inline')
+bool _byteDataRangeEquals(
+  ByteData a,
+  int aStart,
+  ByteData b,
+  int bStart,
+  int count,
+) {
+  int i = 0;
+  // Compare 32 bits at a time in little-endian byte order. Equality is byte-order
+  // invariant, and all supported modern JS runtimes run on little-endian hardware.
+  // Passing a constant `true` enables the JS engine to emit a single direct load
+  // instruction without endian branching or BigInt overhead.
+  final limit32 = count - 4;
+  for (; i <= limit32; i += 4) {
+    if (JS<bool>(
+      'bool',
+      '#.getUint32(#, true) !== #.getUint32(#, true)',
+      a,
+      aStart + i,
+      b,
+      bStart + i,
+    )) {
+      return false;
+    }
+  }
+  for (; i < count; i++) {
+    if (JS<bool>(
+      'bool',
+      '#.getUint8(#) !== #.getUint8(#)',
+      a,
+      aStart + i,
+      b,
+      bStart + i,
+    )) {
+      return false;
+    }
+  }
+  return true;
+}