Specialize mint shift code on ia32 for a constant shift amount.

runtime/vm/intermediate_language_ia32.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 5592 matching lines @@
             Smi::Cast(index_loc.constant()).Value()) ||
            (Smi::Cast(index_loc.constant()).Value() < 0));
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ jmp(deopt);
     return;
   }
 
   if (index_loc.IsConstant()) {
     Register length = length_loc.reg();
-    const Object& index = Smi::Cast(index_loc.constant());
+    const Smi& index = Smi::Cast(index_loc.constant());
     __ cmpl(length, Immediate(reinterpret_cast<int32_t>(index.raw())));
     __ j(BELOW_EQUAL, deopt);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     if (index_loc.IsStackSlot()) {
       const Address& index = index_loc.ToStackSlotAddress();
       __ cmpl(index, Immediate(reinterpret_cast<int32_t>(length.raw())));
     } else {
       Register index = index_loc.reg();
       __ cmpl(index, Immediate(reinterpret_cast<int32_t>(length.raw())));
@@ skipping 266 matching lines @@
 
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps =
       (op_kind() == Token::kSHL) && CanDeoptimize() ? 2 : 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::Pair(Location::RequiresRegister(),
                                     Location::RequiresRegister()));
-  summary->set_in(1, Location::RegisterLocation(ECX));
+  summary->set_in(1, Location::FixedRegisterOrSmiConstant(right(), ECX));
   if ((op_kind() == Token::kSHL) && CanDeoptimize()) {
     summary->set_temp(0, Location::RequiresRegister());
     summary->set_temp(1, Location::RequiresRegister());
   }
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
 
 static const intptr_t kMintShiftCountLimit = 63;
@@ skipping 11 matching lines @@
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
   ASSERT(out_lo == left_lo);
   ASSERT(out_hi == left_hi);
 
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
   }
-  // Deoptimize if shift count is > 63.
-  // sarl operation masks the count to 5 bits and
-  // shrd is undefined with count > operand size (32)
-  __ SmiUntag(ECX);
-  if (has_shift_count_check()) {
-    __ cmpl(ECX, Immediate(kMintShiftCountLimit));
-    __ j(ABOVE, deopt);
-  }
-  // TODO(regis): Specialize code for constant shift amount.
-  Label large_shift, done;
-  switch (op_kind()) {
-    case Token::kSHR: {
-      __ cmpl(ECX, Immediate(31));
-      __ j(ABOVE, &large_shift);
-
-      __ shrd(left_lo, left_hi);  // Shift count in CL.
-      __ sarl(left_hi, ECX);  // Shift count in CL.
-      __ jmp(&done, Assembler::kNearJump);
-
-      __ Bind(&large_shift);
-      __ subl(ECX, Immediate(32));
-      __ movl(left_lo, left_hi);  // Shift by 32.
-      __ sarl(left_hi, Immediate(31));  // Sign extend left hi.
-      __ sarl(left_lo, ECX);  // Shift count - 32 in CL.
-      break;
+  if (locs()->in(1).IsConstant()) {
+    // Code for a constant shift amount.
+    ASSERT(locs()->in(1).constant().IsSmi());
+    const int32_t shift =
+        reinterpret_cast<int32_t>(locs()->in(1).constant().raw()) >> 1;
+    if ((shift < 0) || (shift > kMintShiftCountLimit)) {

[srdjan, 2014/07/10 23:20:15]

For SHR  shouldn't 'shift > kMintShiftCountLimit' produce same shift as with
kMintShiftCountLimit? I.e., 
if (shift > kMintShiftCountLimit) shift = kMintShiftCountLimit;

[regis, 2014/07/10 23:59:27]

I kept the previous semantics. In the case the shift amount is variable and not
known to be in range [0..64[, the function has_shift_count_check() will return
true. This causes range check code to be emitted with a potential deopt jump.
In the case the shift amount is constant and not in range, I can emit the deopt
jump directly. Of course, it would be even better not to optimize, but I did not
want to make changes upstream.

+      __ jmp(deopt);
+      return;
+    } else if (shift == 0) {
+      // Nothing to do for zero shift amount.
+      return;
     }
-    case Token::kSHL: {
-      if (can_overflow()) {
-        Register temp1 = locs()->temp(0).reg();
-        Register temp2 = locs()->temp(1).reg();
-        __ movl(temp1, left_hi);  // Preserve high 32 bits.
+    switch (op_kind()) {
+      case Token::kSHR: {
+        if (shift > 31) {
+          __ movl(left_lo, left_hi);  // Shift by 32.
+          __ sarl(left_hi, Immediate(31));  // Sign extend left hi.
+          if (shift > 32) {
+            __ sarl(left_lo, Immediate(shift - 32));
+          }
+        } else {
+          __ shrd(left_lo, left_hi, Immediate(shift));
+          __ sarl(left_hi, Immediate(shift));
+        }
+        break;
+      }
+      case Token::kSHL: {
+        if (can_overflow()) {
+          Register temp1 = locs()->temp(0).reg();
+          Register temp2 = locs()->temp(1).reg();
+          __ movl(temp1, left_hi);  // Preserve high 32 bits.
+          if (shift > 31) {
+            __ movl(left_hi, left_lo);  // Shift by 32.
+            __ xorl(left_lo, left_lo);  // Zero left_lo.
+            if (shift > 32) {
+              __ shll(left_hi, Immediate(shift - 32));
+            }
+            // Check for overflow by sign extending the high 32 bits
+            // and comparing with the input.
+            __ movl(temp2, left_hi);
+            __ sarl(temp2, Immediate(31));
+            __ cmpl(temp1, temp2);
+            __ j(NOT_EQUAL, deopt);
+          } else {
+            __ shld(left_hi, left_lo, Immediate(shift));
+            __ shll(left_lo, Immediate(shift));
+            // Check for overflow by shifting back the high 32 bits
+            // and comparing with the input.
+            __ movl(temp2, left_hi);
+            __ sarl(temp2, Immediate(shift));
+            __ cmpl(temp1, temp2);
+            __ j(NOT_EQUAL, deopt);
+          }
+        } else {
+          if (shift > 31) {
+            __ movl(left_hi, left_lo);  // Shift by 32.
+            __ xorl(left_lo, left_lo);  // Zero left_lo.
+            if (shift > 32) {
+              __ shll(left_hi, Immediate(shift - 32));
+            }
+          } else {
+            __ shld(left_hi, left_lo, Immediate(shift));
+            __ shll(left_lo, Immediate(shift));
+          }
+        }
+        break;
+      }
+      default:
+        UNREACHABLE();
+        break;
+    }
+  } else {
+    // Code for a variable shift amount.
+    // Deoptimize if shift count is > 63.
+    // sarl operation masks the count to 5 bits and
+    // shrd is undefined with count > operand size (32)
+    __ SmiUntag(ECX);
+    if (has_shift_count_check()) {
+      __ cmpl(ECX, Immediate(kMintShiftCountLimit));
+      __ j(ABOVE, deopt);
+    }
+    Label done, large_shift;
+    switch (op_kind()) {
+      case Token::kSHR: {
         __ cmpl(ECX, Immediate(31));
         __ j(ABOVE, &large_shift);
 
-        __ shld(left_hi, left_lo);  // Shift count in CL.
-        __ shll(left_lo, ECX);  // Shift count in CL.
-        // Check for overflow by shifting back the high 32 bits
-        // and comparing with the input.
-        __ movl(temp2, left_hi);
-        __ sarl(temp2, ECX);
-        __ cmpl(temp1, temp2);
-        __ j(NOT_EQUAL, deopt);
+        __ shrd(left_lo, left_hi);  // Shift count in CL.
+        __ sarl(left_hi, ECX);  // Shift count in CL.
         __ jmp(&done, Assembler::kNearJump);
 
         __ Bind(&large_shift);
         __ subl(ECX, Immediate(32));
-        __ movl(left_hi, left_lo);  // Shift by 32.
-        __ xorl(left_lo, left_lo);  // Zero left_lo.
-        __ shll(left_hi, ECX);  // Shift count in CL.
-        // Check for overflow by sign extending the high 32 bits
-        // and comparing with the input.
-        __ movl(temp2, left_hi);
-        __ sarl(temp2, Immediate(31));
-        __ cmpl(temp1, temp2);
-        __ j(NOT_EQUAL, deopt);
-      } else {
-        __ cmpl(ECX, Immediate(31));
-        __ j(ABOVE, &large_shift);
+        __ movl(left_lo, left_hi);  // Shift by 32.
+        __ sarl(left_hi, Immediate(31));  // Sign extend left hi.
+        __ sarl(left_lo, ECX);  // Shift count - 32 in CL.
+        break;
+      }
+      case Token::kSHL: {
+        if (can_overflow()) {
+          Register temp1 = locs()->temp(0).reg();
+          Register temp2 = locs()->temp(1).reg();
+          __ movl(temp1, left_hi);  // Preserve high 32 bits.
+          __ cmpl(ECX, Immediate(31));
+          __ j(ABOVE, &large_shift);
 
-        __ shld(left_hi, left_lo);  // Shift count in CL.
-        __ shll(left_lo, ECX);  // Shift count in CL.
-        __ jmp(&done, Assembler::kNearJump);
+          __ shld(left_hi, left_lo);  // Shift count in CL.
+          __ shll(left_lo, ECX);  // Shift count in CL.
+          // Check for overflow by shifting back the high 32 bits
+          // and comparing with the input.
+          __ movl(temp2, left_hi);
+          __ sarl(temp2, ECX);
+          __ cmpl(temp1, temp2);
+          __ j(NOT_EQUAL, deopt);
+          __ jmp(&done, Assembler::kNearJump);
 
-        __ Bind(&large_shift);
-        __ subl(ECX, Immediate(32));
-        __ movl(left_hi, left_lo);  // Shift by 32.
-        __ xorl(left_lo, left_lo);  // Zero left_lo.
-        __ shll(left_hi, ECX);  // Shift count in CL.
+          __ Bind(&large_shift);
+          __ subl(ECX, Immediate(32));
+          __ movl(left_hi, left_lo);  // Shift by 32.
+          __ xorl(left_lo, left_lo);  // Zero left_lo.
+          __ shll(left_hi, ECX);  // Shift count in CL.
+          // Check for overflow by sign extending the high 32 bits
+          // and comparing with the input.
+          __ movl(temp2, left_hi);
+          __ sarl(temp2, Immediate(31));
+          __ cmpl(temp1, temp2);
+          __ j(NOT_EQUAL, deopt);
+        } else {
+          __ cmpl(ECX, Immediate(31));
+          __ j(ABOVE, &large_shift);
+
+          __ shld(left_hi, left_lo);  // Shift count in CL.
+          __ shll(left_lo, ECX);  // Shift count in CL.
+          __ jmp(&done, Assembler::kNearJump);
+
+          __ Bind(&large_shift);
+          __ subl(ECX, Immediate(32));
+          __ movl(left_hi, left_lo);  // Shift by 32.
+          __ xorl(left_lo, left_lo);  // Zero left_lo.
+          __ shll(left_hi, ECX);  // Shift count in CL.
+        }
+        break;
       }
-      break;
+      default:
+        UNREACHABLE();
+        break;
     }
-    default:
-      UNREACHABLE();
-      break;
+    __ Bind(&done);
   }
-  __ Bind(&done);
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptIntOverflowCheck(compiler, deopt, left_lo, left_hi);
   }
 }
 
 
 LocationSummary* UnaryMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 388 matching lines @@
   __ movl(EDX, Immediate(kInvalidObjectPointer));
   __ movl(EDX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32