tor-browser

commit b48243d060f0e0bd84e66d795ddcec182214b3dc
parent 1949d39c47bf940312a88072d90d0e49775d21e7
Author: André Bargull <andre.bargull@gmail.com>
Date:   Mon, 27 Oct 2025 09:00:02 +0000

Bug 1996346 - Part 4: Don't reuse input for Int64 shift instructions when BMI2 is available. r=spidermonkey-reviewers,iain

Similar to the changes from part 1.

Differential Revision: https://phabricator.services.mozilla.com/D270028

Diffstat:
M
js/src/jit/x64/CodeGenerator-x64.cpp
 | 
33
++++++++++++++++++++++++---------
M
js/src/jit/x64/Lowering-x64.cpp
 | 
31
+++++++++++++++++++++----------

2 files changed, 45 insertions(+), 19 deletions(-)
diff --git a/js/src/jit/x64/CodeGenerator-x64.cpp b/js/src/jit/x64/CodeGenerator-x64.cpp
@@ -366,27 +366,28 @@ void CodeGenerator::visitShiftIntPtr(LShiftIntPtr* ins) {
 }
 
 void CodeGenerator::visitShiftI64(LShiftI64* lir) {
-  Register64 lhs = ToRegister64(lir->lhs());
+  Register lhs = ToRegister64(lir->lhs()).reg;
   const LAllocation* rhs = lir->rhs();
-
-  MOZ_ASSERT(ToOutRegister64(lir) == lhs);
+  Register out = ToOutRegister64(lir).reg;
 
   if (rhs->isConstant()) {
+    MOZ_ASSERT(out == lhs);
+
     int32_t shift = int32_t(rhs->toConstant()->toInt64() & 0x3F);
     switch (lir->bitop()) {
       case JSOp::Lsh:
         if (shift) {
-          masm.lshift64(Imm32(shift), lhs);
+          masm.lshiftPtr(Imm32(shift), lhs);
         }
         break;
       case JSOp::Rsh:
         if (shift) {
-          masm.rshift64Arithmetic(Imm32(shift), lhs);
+          masm.rshiftPtrArithmetic(Imm32(shift), lhs);
         }
         break;
       case JSOp::Ursh:
         if (shift) {
-          masm.rshift64(Imm32(shift), lhs);
+          masm.rshiftPtr(Imm32(shift), lhs);
         }
         break;
       default:
@@ -396,15 +397,29 @@ void CodeGenerator::visitShiftI64(LShiftI64* lir) {
   }
 
   Register shift = ToRegister(rhs);
+  MOZ_ASSERT_IF(out != lhs, Assembler::HasBMI2());
+
   switch (lir->bitop()) {
     case JSOp::Lsh:
-      masm.lshift64(shift, lhs);
+      if (out != lhs) {
+        masm.shlxq(lhs, shift, out);
+      } else {
+        masm.lshiftPtr(shift, lhs);
+      }
       break;
     case JSOp::Rsh:
-      masm.rshift64Arithmetic(shift, lhs);
+      if (out != lhs) {
+        masm.sarxq(lhs, shift, out);
+      } else {
+        masm.rshiftPtrArithmetic(shift, lhs);
+      }
       break;
     case JSOp::Ursh:
-      masm.rshift64(shift, lhs);
+      if (out != lhs) {
+        masm.shrxq(lhs, shift, out);
+      } else {
+        masm.rshiftPtr(shift, lhs);
+      }
       break;
     default:
       MOZ_CRASH("Unexpected shift op");
diff --git a/js/src/jit/x64/Lowering-x64.cpp b/js/src/jit/x64/Lowering-x64.cpp
@@ -83,20 +83,31 @@ void LIRGeneratorX64::lowerForMulInt64(LMulI64* ins, MMul* mir,
 template <class LInstr>
 void LIRGeneratorX64::lowerForShiftInt64(LInstr* ins, MDefinition* mir,
                                          MDefinition* lhs, MDefinition* rhs) {
-  LAllocation rhsAlloc;
-  if (rhs->isConstant()) {
-    rhsAlloc = useOrConstantAtStart(rhs);
-  } else if (std::is_same_v<LInstr, LShiftI64>) {
-    rhsAlloc = useShiftRegister(rhs);
-  } else {
-    rhsAlloc = useFixed(rhs, rcx);
-  }
-
   if constexpr (std::is_same_v<LInstr, LShiftI64>) {
+    LAllocation rhsAlloc;
+    if (rhs->isConstant()) {
+      rhsAlloc = useOrConstantAtStart(rhs);
+    } else if (Assembler::HasBMI2()) {
+      rhsAlloc = useRegisterAtStart(rhs);
+    } else {
+      rhsAlloc = useShiftRegister(rhs);
+    }
+
     ins->setLhs(useInt64RegisterAtStart(lhs));
     ins->setRhs(rhsAlloc);
-    defineInt64ReuseInput(ins, mir, LShiftI64::LhsIndex);
+    if (rhs->isConstant() || !Assembler::HasBMI2()) {
+      defineInt64ReuseInput(ins, mir, LShiftI64::LhsIndex);
+    } else {
+      defineInt64(ins, mir);
+    }
   } else {
+    LAllocation rhsAlloc;
+    if (rhs->isConstant()) {
+      rhsAlloc = useOrConstantAtStart(rhs);
+    } else {
+      rhsAlloc = useFixed(rhs, rcx);
+    }
+
     ins->setInput(useInt64RegisterAtStart(lhs));
     ins->setCount(rhsAlloc);
     defineInt64ReuseInput(ins, mir, LRotateI64::InputIndex);