[vm] Use an SSHR-based sign mask on arm64

- adds missing float64x2 tests
- modernizes existing tests and tests for more edge cases

TEST=lib/typed_data/int32x4_sign_mask_test lib/typed_data/float32x4_sign_mask_test lib/typed_data/float64x2_sign_mask_test

Fixed: #41950
Issue: #64170
Change-Id: I5166bf31d1a4005c427b02c0d9d1c4bbaa9f63ec
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/542362
Auto-Submit: Modestas Valauskas <valauskasmodestas@gmail.com>
Reviewed-by: Lasse Nielsen <lrn@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Commit-Queue: Martin Kustermann <kustermann@google.com>

Author: modulovalue

runtime/vm/compiler/backend/il_arm64.cc

@@ -4113,22 +4113,17 @@ DEFINE_EMIT(SimdUnaryOp, (VRegister result, VRegister value)) {
 }
 
 DEFINE_EMIT(Simd32x4GetSignMask,
-            (Register out, VRegister value, Temp<Register> temp)) {
-  // X lane.
-  __ vmovrs(out, value, 0);
-  __ LsrImmediate(out, out, 31);
-  // Y lane.
-  __ vmovrs(temp, value, 1);
-  __ LsrImmediate(temp, temp, 31);
-  __ orr(out, out, compiler::Operand(temp, LSL, 1));
-  // Z lane.
-  __ vmovrs(temp, value, 2);
-  __ LsrImmediate(temp, temp, 31);
-  __ orr(out, out, compiler::Operand(temp, LSL, 2));
-  // W lane.
-  __ vmovrs(temp, value, 3);
-  __ LsrImmediate(temp, temp, 31);
-  __ orr(out, out, compiler::Operand(temp, LSL, 3));
+            (Register out, VRegister value, Temp<VRegister> temp)) {
+  simd128_value_t weights;
+  weights.int_storage[0] = 1;
+  weights.int_storage[1] = 2;
+  weights.int_storage[2] = 4;
+  weights.int_storage[3] = 8;
+  __ vsshr_4s(VTMP, value, 31);
+  __ LoadQImmediate(temp, weights);
+  __ vand(VTMP, VTMP, temp);
+  __ vuaddlv_4s(VTMP, VTMP);
+  __ fmovrs(out, VTMP);
 }
 
 DEFINE_EMIT(

tests/lib/typed_data/float32x4_sign_mask_test.dart

@@ -12,53 +12,54 @@ import 'dart:typed_data';
 import 'package:expect/expect.dart';
 
 void testImmediates() {
-  var f = Float32x4(1.0, 2.0, 3.0, 4.0);
-  var m = f.signMask;
-  Expect.equals(0x0, m);
-  f = Float32x4(-1.0, -2.0, -3.0, -0.0);
-  m = f.signMask;
-  Expect.equals(0xf, m);
-  f = Float32x4(-1.0, 2.0, 3.0, 4.0);
-  m = f.signMask;
-  Expect.equals(0x1, m);
-  f = Float32x4(1.0, -2.0, 3.0, 4.0);
-  m = f.signMask;
-  Expect.equals(0x2, m);
-  f = Float32x4(1.0, 2.0, -3.0, 4.0);
-  m = f.signMask;
-  Expect.equals(0x4, m);
-  f = Float32x4(1.0, 2.0, 3.0, -4.0);
-  m = f.signMask;
-  Expect.equals(0x8, m);
+  Expect.equals(0x0, Float32x4(1.0, 2.0, 3.0, 4.0).signMask);
+  Expect.equals(0xf, Float32x4(-1.0, -2.0, -3.0, -0.0).signMask);
+  Expect.equals(0x1, Float32x4(-1.0, 2.0, 3.0, 4.0).signMask);
+  Expect.equals(0x2, Float32x4(1.0, -2.0, 3.0, 4.0).signMask);
+  Expect.equals(0x4, Float32x4(1.0, 2.0, -3.0, 4.0).signMask);
+  Expect.equals(0x8, Float32x4(1.0, 2.0, 3.0, -4.0).signMask);
 }
 
 void testZero() {
-  var f = Float32x4(0.0, 0.0, 0.0, 0.0);
-  var m = f.signMask;
-  Expect.equals(0x0, m);
-  f = Float32x4(-0.0, -0.0, -0.0, -0.0);
-  m = f.signMask;
-  Expect.equals(0xf, m);
+  Expect.equals(0x0, Float32x4(0.0, 0.0, 0.0, 0.0).signMask);
+  Expect.equals(0xf, Float32x4(-0.0, -0.0, -0.0, -0.0).signMask);
 }
 
 void testArithmetic() {
-  var a = Float32x4(1.0, 1.0, 1.0, 1.0);
-  var b = Float32x4(2.0, 2.0, 2.0, 2.0);
-  var c = Float32x4(-1.0, -1.0, -1.0, -1.0);
-  var m1 = (a - b).signMask;
-  Expect.equals(0xf, m1);
-  var m2 = (b - a).signMask;
-  Expect.equals(0x0, m2);
-  var m3 = (c * c).signMask;
-  Expect.equals(0x0, m3);
-  var m4 = (a * c).signMask;
-  Expect.equals(0xf, m4);
+  final a = Float32x4(1.0, 1.0, 1.0, 1.0);
+  final b = Float32x4(2.0, 2.0, 2.0, 2.0);
+  final c = Float32x4(-1.0, -1.0, -1.0, -1.0);
+  Expect.equals(0xf, (a - b).signMask);
+  Expect.equals(0x0, (b - a).signMask);
+  Expect.equals(0x0, (c * c).signMask);
+  Expect.equals(0xf, (a * c).signMask);
+}
+
+// Check every one of the 16 sign-bit patterns: lane i is negative when bit i of
+// `mask` is set, so signMask should return `mask`.
+void testExhaustive() {
+  for (int mask = 0; mask < 16; mask++) {
+    double lane(int i) => (mask & (1 << i)) != 0 ? -1.0 : 1.0;
+    Expect.equals(mask, Float32x4(lane(0), lane(1), lane(2), lane(3)).signMask);
+  }
+}
+
+void testSpecialValues() {
+  const inf = double.infinity;
+  Expect.equals(0x0, Float32x4(inf, inf, inf, inf).signMask);
+  Expect.equals(0xf, Float32x4(-inf, -inf, -inf, -inf).signMask);
+  Expect.equals(0x5, Float32x4(-inf, 1.0, -inf, 1.0).signMask);
+  // NaN is intentionally not tested. The sign bit of a NaN is not portable
+  // across architectures or the web backends.
+  Expect.equals(0xf, Float32x4(-1e-40, -1e-40, -1e-40, -1e-40).signMask);
 }
 
 main() {
   for (int i = 0; i < 2000; i++) {
     testImmediates();
     testZero();
     testArithmetic();
+    testExhaustive();
+    testSpecialValues();
   }
 }

tests/lib/typed_data/float64x2_sign_mask_test.dart

@@ -0,0 +1,52 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// 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.
+
+// VMOptions=--optimization-counter-threshold=10 --no-background-compilation
+
+// Library tag to be able to run in html test framework.
+library float64x2_sign_mask;
+
+import 'dart:typed_data';
+
+import 'package:expect/expect.dart';
+
+void testImmediates() {
+  Expect.equals(0x0, Float64x2(1.0, 2.0).signMask);
+  Expect.equals(0x3, Float64x2(-1.0, -2.0).signMask);
+  Expect.equals(0x1, Float64x2(-1.0, 2.0).signMask);
+  Expect.equals(0x2, Float64x2(1.0, -2.0).signMask);
+}
+
+void testZero() {
+  Expect.equals(0x0, Float64x2(0.0, 0.0).signMask);
+  Expect.equals(0x3, Float64x2(-0.0, -0.0).signMask);
+}
+
+// Check every one of the 4 sign-bit patterns: lane i is negative when bit i of
+// `mask` is set, so signMask should return `mask`.
+void testExhaustive() {
+  for (int mask = 0; mask < 4; mask++) {
+    double lane(int i) => (mask & (1 << i)) != 0 ? -1.0 : 1.0;
+    Expect.equals(mask, Float64x2(lane(0), lane(1)).signMask);
+  }
+}
+
+void testSpecialValues() {
+  const inf = double.infinity;
+  Expect.equals(0x0, Float64x2(inf, inf).signMask);
+  Expect.equals(0x3, Float64x2(-inf, -inf).signMask);
+  Expect.equals(0x1, Float64x2(-inf, inf).signMask);
+  // NaN is intentionally not tested. The sign bit of a NaN is not portable
+  // across architectures or the web backends.
+  Expect.equals(0x3, Float64x2(-5e-324, -5e-324).signMask);
+}
+
+main() {
+  for (int i = 0; i < 2000; i++) {
+    testImmediates();
+    testZero();
+    testExhaustive();
+    testSpecialValues();
+  }
+}

tests/lib/typed_data/int32x4_sign_mask_test.dart

@@ -12,53 +12,44 @@ import 'dart:typed_data';
 import 'package:expect/expect.dart';
 
 void testImmediates() {
-  var f = Int32x4(1, 2, 3, 4);
-  var m = f.signMask;
-  Expect.equals(0x0, m);
-  f = Int32x4(-1, -2, -3, -4);
-  m = f.signMask;
-  Expect.equals(0xf, m);
-  f = Int32x4.bool(true, false, false, false);
-  m = f.signMask;
-  Expect.equals(0x1, m);
-  f = Int32x4.bool(false, true, false, false);
-  m = f.signMask;
-  Expect.equals(0x2, m);
-  f = Int32x4.bool(false, false, true, false);
-  m = f.signMask;
-  Expect.equals(0x4, m);
-  f = Int32x4.bool(false, false, false, true);
-  m = f.signMask;
-  Expect.equals(0x8, m);
+  Expect.equals(0x0, Int32x4(1, 2, 3, 4).signMask);
+  Expect.equals(0xf, Int32x4(-1, -2, -3, -4).signMask);
+  Expect.equals(0x1, Int32x4.bool(true, false, false, false).signMask);
+  Expect.equals(0x2, Int32x4.bool(false, true, false, false).signMask);
+  Expect.equals(0x4, Int32x4.bool(false, false, true, false).signMask);
+  Expect.equals(0x8, Int32x4.bool(false, false, false, true).signMask);
 }
 
 void testZero() {
-  var f = Int32x4(0, 0, 0, 0);
-  var m = f.signMask;
-  Expect.equals(0x0, m);
-  f = Int32x4(-0, -0, -0, -0);
-  m = f.signMask;
-  Expect.equals(0x0, m);
+  Expect.equals(0x0, Int32x4(0, 0, 0, 0).signMask);
+  Expect.equals(0x0, Int32x4(-0, -0, -0, -0).signMask);
 }
 
 void testLogic() {
-  var a = Int32x4(0x80000000, 0x80000000, 0x80000000, 0x80000000);
-  var b = Int32x4(0x70000000, 0x70000000, 0x70000000, 0x70000000);
-  var c = Int32x4(0xf0000000, 0xf0000000, 0xf0000000, 0xf0000000);
-  var m1 = (a & c).signMask;
-  Expect.equals(0xf, m1);
-  var m2 = (a & b).signMask;
-  Expect.equals(0x0, m2);
-  var m3 = (b ^ a).signMask;
-  Expect.equals(0xf, m3);
-  var m4 = (b | c).signMask;
-  Expect.equals(0xf, m4);
+  final a = Int32x4(0x80000000, 0x80000000, 0x80000000, 0x80000000);
+  final b = Int32x4(0x70000000, 0x70000000, 0x70000000, 0x70000000);
+  final c = Int32x4(0xf0000000, 0xf0000000, 0xf0000000, 0xf0000000);
+  Expect.equals(0xf, (a & c).signMask);
+  Expect.equals(0x0, (a & b).signMask);
+  Expect.equals(0xf, (b ^ a).signMask);
+  Expect.equals(0xf, (b | c).signMask);
+}
+
+// Check every one of the 16 sign-bit patterns: lane i is negative when bit i of
+// `mask` is set, so signMask should return `mask`. Positive lanes use 0x7fffffff
+// (all bits but the sign) to confirm only the sign bit is read.
+void testExhaustive() {
+  for (int mask = 0; mask < 16; mask++) {
+    int lane(int i) => (mask & (1 << i)) != 0 ? 0x80000000 : 0x7fffffff;
+    Expect.equals(mask, Int32x4(lane(0), lane(1), lane(2), lane(3)).signMask);
+  }
 }
 
 main() {
   for (int i = 0; i < 2000; i++) {
     testImmediates();
     testZero();
     testLogic();
+    testExhaustive();
   }
 }