Revert r14711 and r14709 because of test failures.

runtime/vm/intermediate_language_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 1594 matching lines @@
     return summary;
   } else if (op_kind() == Token::kSHR) {
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::SameAsFirstInput());
     return summary;
   } else if (op_kind() == Token::kSHL) {
-    const intptr_t kNumTemps = 1;
+    // Two Smi operands can easily overflow into Mint.
+    const intptr_t kNumTemps = 2;
     LocationSummary* summary =
-        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    summary->set_in(0, Location::RequiresRegister());
-    summary->set_in(1, Location::FixedRegisterOrConstant(right(), RCX));
-    summary->set_temp(0, Location::RequiresRegister());
-    summary->set_out(Location::SameAsFirstInput());
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+    summary->set_in(0, Location::RegisterLocation(RAX));
+    summary->set_in(1, Location::RegisterLocation(RDX));
+    summary->set_out(Location::RegisterLocation(RAX));
+    summary->set_temp(0, Location::RegisterLocation(RBX));
+    summary->set_temp(1, Location::RegisterLocation(RCX));
     return summary;
   } else {
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     return summary;
   }
@@ skipping 56 matching lines @@
           break;
         }
 
         value = value + kSmiTagSize;
         if (value >= kCountLimit) value = kCountLimit;
 
         __ sarq(left, Immediate(value));
         __ SmiTag(left);
         break;
       }
-      case Token::kSHL: {
-        // shlq operation masks the count to 6 bits.
-        const intptr_t kCountLimit = 0x3F;
-        intptr_t value = Smi::Cast(constant).Value();
-        if (value == 0) break;
-        if ((value < 0) || (value >= kCountLimit)) {
-          // This condition may not be known earlier in some cases because
-          // of constant propagation, inlining, etc.
-          __ jmp(deopt);
-          break;
-        }
-        Register temp = locs()->temp(0).reg();
-        __ movq(temp, left);
-        __ shlq(left, Immediate(value));
-        __ sarq(left, Immediate(value));
-        __ cmpq(left, temp);
-        __ j(NOT_EQUAL, deopt);  // Overflow.
-        // Shift for result now we know there is no overflow.
-        __ shlq(left, Immediate(value));
-        break;
-      }
-
       default:
         UNREACHABLE();
         break;
     }
     return;
   }
 
   Register right = locs()->in(1).reg();
   switch (op_kind()) {
     case Token::kADD: {
@@ skipping 63 matching lines @@
       __ movq(right, kCountLimit);
       __ Bind(&count_ok);
       ASSERT(right == RCX);  // Count must be in RCX
       __ SmiUntag(left);
       __ sarq(left, right);
       __ SmiTag(left);
       break;
     }
     case Token::kSHL: {
       Register temp = locs()->temp(0).reg();
+      Label call_method, done;
       // Check if count too large for handling it inlined.
       __ movq(temp, left);
       Range* right_range = this->right()->definition()->range();
       const bool right_needs_check =
           (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
       if (right_needs_check) {
         __ cmpq(right,
             Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
-        __ j(ABOVE_EQUAL, deopt);
+        __ j(ABOVE_EQUAL, &call_method, Assembler::kNearJump);
       }
-      ASSERT(right == RCX);  // Count must be in RCX
-      __ SmiUntag(right);
+      Register right_temp = locs()->temp(1).reg();
+      ASSERT(right_temp == RCX);  // Count must be in RCX
+      __ movq(right_temp, right);
+      __ SmiUntag(right_temp);
       // Overflow test (preserve temp and right);
-      __ shlq(left, right);
-      __ sarq(left, right);
+      __ shlq(left, right_temp);
+      __ sarq(left, right_temp);
       __ cmpq(left, temp);
-      __ j(NOT_EQUAL, deopt);  // Overflow.
+      __ j(NOT_EQUAL, &call_method, Assembler::kNearJump);  // Overflow.
       // Shift for result now we know there is no overflow.
-      __ shlq(left, right);
+      __ shlq(left, right_temp);
+      __ jmp(&done);
+      {
+        __ Bind(&call_method);
+        Function& target = Function::ZoneHandle(
+            ic_data()->GetTargetForReceiverClassId(kSmiCid));
+        ASSERT(!target.IsNull());
+        const intptr_t kArgumentCount = 2;
+        __ pushq(temp);
+        __ pushq(right);
+        compiler->GenerateStaticCall(
+            deopt_id(),
+            instance_call()->token_pos(),
+            target,
+            kArgumentCount,
+            Array::Handle(),  // No argument names.
+            locs());
+        ASSERT(result == RAX);
+      }
+      __ Bind(&done);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
     }
     case Token::kMOD: {
       // TODO(srdjan): Implement.
@@ skipping 523 matching lines @@
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64