[vm, compiler] Don't use MayBeSameAsFirstInput for smi srl.

TEST=ci
Bug: #59611
Change-Id: I6a41e690e048163eaa71a02924a6c942e9fdc93b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/397641
Commit-Queue: Ryan Macnak <[email protected]>
Reviewed-by: Alexander Aprelev <[email protected]>

Author: rmacnak-google

runtime/tests/vm/dart/regress_59611_test.dart

@@ -0,0 +1,22 @@
+// Copyright (c) 2024, 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.
+
+// The Dart Project Fuzz Tester (1.101).
+// Program generated as:
+//   dart dartfuzz.dart --seed 1868073336 --no-fp --no-ffi --flat
+// @dart=2.14
+
+// VMOptions=--optimization_counter_threshold=1 --use-slow-path --deterministic
+
+import "dart:typed_data";
+
+Uint8ClampedList var9 = Uint8ClampedList(40);
+bool var109 = true;
+int var112 = 5;
+
+main() {
+  for (int loc0 = 0; loc0 < 41; loc0++) {
+    var112 = var9[27] >>> (var109 ? 38 : 255);
+  }
+}

runtime/tests/vm/dart/smi_ops_test.dart

@@ -0,0 +1,97 @@
+// Copyright (c) 2024, 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=50 --no-background-compilation
+
+import "package:expect/expect.dart";
+
+@pragma("vm:never-inline")
+dynamic smi_add(dynamic x, dynamic y) => x + y;
+
+@pragma("vm:never-inline")
+dynamic smi_sub(dynamic x, dynamic y) => x - y;
+
+@pragma("vm:never-inline")
+dynamic smi_mul(dynamic x, dynamic y) => x * y;
+
+@pragma("vm:never-inline")
+dynamic smi_and(dynamic x, dynamic y) => x & y;
+
+@pragma("vm:never-inline")
+dynamic smi_or(dynamic x, dynamic y) => x | y;
+
+@pragma("vm:never-inline")
+dynamic smi_xor(dynamic x, dynamic y) => x ^ y;
+
+@pragma("vm:never-inline")
+dynamic smi_div(dynamic x, dynamic y) => x ~/ y;
+
+@pragma("vm:never-inline")
+dynamic smi_mod(dynamic x, dynamic y) => x % y;
+
+@pragma("vm:never-inline")
+dynamic smi_sll(dynamic x, dynamic y) => x << y;
+
+@pragma("vm:never-inline")
+dynamic smi_sra(dynamic x, dynamic y) => x >> y;
+
+@pragma("vm:never-inline")
+dynamic smi_srl(dynamic x, dynamic y) => x >>> y;
+
+testSmi() {
+  Expect.equals(7, smi_add(3, 4));
+  Expect.equals(-1, smi_sub(3, 4));
+  Expect.equals(12, smi_mul(3, 4));
+  Expect.equals(0, smi_and(3, 4));
+  Expect.equals(7, smi_or(3, 4));
+  Expect.equals(7, smi_xor(3, 4));
+  Expect.equals(0, smi_div(3, 4));
+  Expect.equals(3, smi_mod(3, 4));
+  Expect.equals(48, smi_sll(3, 4));
+  Expect.equals(0, smi_sra(3, 4));
+  Expect.equals(0, smi_srl(3, 4));
+}
+
+const maxSmi32 = 0x3FFFFFFF;
+const maxSmi64 = 0x3FFFFFFFFFFFFFFF;
+const minSmi32 = -0x80000000;
+const minSmi64 = -0x8000000000000000;
+
+testSmiDeopt() {
+  Expect.equals(0x40000000, smi_add(maxSmi32, 1));
+  Expect.equals(0x4000000000000000, smi_add(maxSmi64, 1));
+
+  Expect.equals(0x40000000, smi_sub(maxSmi32, -1));
+  Expect.equals(0x4000000000000000, smi_sub(maxSmi64, -1));
+
+  Expect.equals(0x7FFFFFFE, smi_mul(maxSmi32, 2));
+  Expect.equals(0x7FFFFFFFFFFFFFFE, smi_mul(maxSmi64, 2));
+
+  Expect.equals(0x80000000, smi_div(minSmi32, -1));
+  Expect.equals(0x8000000000000000, smi_div(minSmi64, -1));
+
+  Expect.throws(() => smi_mod(minSmi32, 0));
+  Expect.throws(() => smi_mod(minSmi64, 0));
+
+  Expect.equals(0x7FFFFFFE, smi_sll(maxSmi32, 1));
+  Expect.equals(0x7FFFFFFFFFFFFFFE, smi_sll(maxSmi64, 1));
+
+  Expect.equals(0, smi_sra(maxSmi32, 65));
+  Expect.equals(0, smi_sra(maxSmi64, 65));
+
+  Expect.equals(0, smi_srl(minSmi32, 65));
+  Expect.equals(0, smi_srl(minSmi64, 65));
+}
+
+main() {
+  for (int i = 0; i < 200; i++) {
+    testSmi();
+  }
+
+  print("=================================");
+
+  for (int i = 0; i < 200; i++) {
+    testSmiDeopt();
+  }
+}

runtime/vm/compiler/backend/il_riscv.cc

@@ -3233,8 +3233,11 @@ LocationSummary* BinarySmiOpInstr::MakeLocationSummary(Zone* zone,
   if (kNumTemps == 1) {
     summary->set_temp(0, Location::RequiresRegister());
   }
-  summary->set_out(0, CanDeoptimize() ? Location::RequiresRegister()
-                                      : Location::MayBeSameAsFirstInput());
+  if (CanDeoptimize() || (op_kind() == Token::kUSHR)) {
+    summary->set_out(0, Location::RequiresRegister());
+  } else {
+    summary->set_out(0, Location::MayBeSameAsFirstInput());
+  }
   return summary;
 }
 
@@ -3491,6 +3494,7 @@ void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
       compiler::Label done, adjust;
       __ bgez(result, &done, compiler::Assembler::kNearJump);
       // Result is negative, adjust it.
+      ASSERT(result != right);
       __ bgez(right, &adjust, compiler::Assembler::kNearJump);
       __ sub(result, result, TMP2);
       __ j(&done, compiler::Assembler::kNearJump);