Enables more VM tests for SIMMIPS.

runtime/vm/intermediate_language_mips.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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 250 matching lines @@
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ TraceSimMsg("AssertBooleanInstr");
   EmitAssertBoolean(obj, token_pos(), deopt_id(), locs(), compiler);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* ArgumentDefinitionTestInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  locs->set_in(0, Location::RegisterLocation(T0));
+  locs->set_out(Location::RegisterLocation(T0));
+  return locs;
 }
 
 
 void ArgumentDefinitionTestInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register saved_args_desc = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  __ TraceSimMsg("ArgumentDefinitionTestInstr");
+
+  __ addiu(SP, SP, Immediate(-4 * kWordSize));
+  // Push the result place holder initialized to NULL.
+  __ LoadObject(TMP1, Object::ZoneHandle());
+  __ sw(TMP1, Address(SP, 3 * kWordSize));
+  __ LoadImmediate(TMP1, Smi::RawValue(formal_parameter_index()));
+  __ sw(TMP1, Address(SP, 2 * kWordSize));
+  __ LoadObject(TMP1, formal_parameter_name());
+  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ sw(saved_args_desc, Address(SP, 0 * kWordSize));
+  compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
+                                kArgumentDefinitionTestRuntimeEntry,
+                                locs());
+  __ lw(result, Address(SP, 3 * kWordSize));  // Pop bool result.
+  __ addiu(SP, SP, Immediate(4 * kWordSize));
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (receiver_class_id() == kMintCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
@@ skipping 60 matching lines @@
 // A1: left.
 // A0: right.
 // Uses T0 to load ic_call_data.
 // Result in V0.
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        Token::Kind kind,
                                        LocationSummary* locs,
                                        const ICData& original_ic_data) {
-  __ TraceSimMsg("EmitEqualityAsInstanceCall");
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id,
                                    token_pos);
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
+  __ TraceSimMsg("EmitEqualityAsInstanceCall");
   Label check_identity;
+  __ lw(A1, Address(SP, 1 * kWordSize));
+  __ lw(A0, Address(SP, 0 * kWordSize));
   __ beq(A1, NULLREG, &check_identity);
   __ beq(A0, NULLREG, &check_identity);
 
   ICData& equality_ic_data = ICData::ZoneHandle();
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
     if (original_ic_data.NumberOfChecks() == 0) {
       // IC call for reoptimization populates original ICData.
       equality_ic_data = original_ic_data.raw();
     } else {
       // Megamorphic call.
       equality_ic_data = original_ic_data.AsUnaryClassChecks();
     }
   } else {
     equality_ic_data = ICData::New(compiler->parsed_function().function(),
                                    Symbols::EqualOperator(),
                                    deopt_id,
                                    kNumArgumentsChecked);
   }
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(A1, Address(SP, 1 * kWordSize));
-  __ sw(A0, Address(SP, 0 * kWordSize));
   compiler->GenerateInstanceCall(deopt_id,
                                  token_pos,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  locs,
                                  equality_ic_data);
   Label check_ne;
   __ b(&check_ne);
 
   __ Bind(&check_identity);
   Label equality_done;
   if (compiler->is_optimizing()) {
     // No need to update IC data.
     Label is_true;
+    __ lw(A1, Address(SP, 1 * kWordSize));
+    __ lw(A0, Address(SP, 0 * kWordSize));
+    __ addiu(SP, SP, Immediate(2 * kWordSize));
     __ beq(A1, A0, &is_true);
     __ LoadObject(V0, (kind == Token::kEQ) ? Bool::False() : Bool::True());
     __ b(&equality_done);
     __ Bind(&is_true);
     __ LoadObject(V0, (kind == Token::kEQ) ? Bool::True() : Bool::False());
     if (kind == Token::kNE) {
       // Skip not-equal result conversion.
       __ b(&equality_done);
     }
   } else {
     // Call stub, load IC data in register. The stub will update ICData if
     // necessary.
     Register ic_data_reg = locs->temp(0).reg();
     ASSERT(ic_data_reg == T0);  // Stub depends on it.
     __ LoadObject(ic_data_reg, equality_ic_data);
     // Pass left in A1 and right in A0.
     compiler->GenerateCall(token_pos,
                            &StubCode::EqualityWithNullArgLabel(),
                            PcDescriptors::kRuntimeCall,
                            locs);
+    __ Drop(2);
   }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     Label true_label, done;
     // Negate the condition: true label returns false and vice versa.
     __ BranchEqual(V0, Bool::True(), &true_label);
     __ LoadObject(V0, Bool::True());
     __ b(&done);
     __ Bind(&true_label);
     __ LoadObject(V0, Bool::False());
@@ skipping 16 matching lines @@
   if (value_is_smi == NULL) {
     __ beq(TMP1, ZR, &done);
   } else {
     __ beq(TMP1, ZR, value_is_smi);
   }
   __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
 
 
+static Condition TokenKindToSmiCondition(Token::Kind kind) {
+  switch (kind) {
+    case Token::kEQ: return EQ;
+    case Token::kNE: return NE;
+    case Token::kLT: return LT;
+    case Token::kGT: return GT;
+    case Token::kLTE: return LE;
+    case Token::kGTE: return GE;
+    default:
+      UNREACHABLE();
+      return VS;
+  }
+}
+
+
+// Branches on condition c assuming comparison results in CMPRES and TMP1.
+static void EmitBranchAfterCompare(
+    FlowGraphCompiler* compiler, Condition c, Label* is_true) {
+  switch (c) {
+    case EQ: __ beq(CMPRES, TMP1, is_true); break;
+    case NE: __ bne(CMPRES, TMP1, is_true); break;
+    case GT: __ bne(TMP1, ZR, is_true); break;
+    case GE: __ beq(CMPRES, ZR, is_true); break;
+    case LT: __ bne(CMPRES, ZR, is_true); break;
+    case LE: __ beq(TMP1, ZR, is_true); break;
+    default:
+      UNREACHABLE();
+      break;
+  }
+}
+
+
+// A1: left, also on stack.
+// A0: right, also on stack.
+static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
+                                          const ICData& orig_ic_data,
+                                          LocationSummary* locs,
+                                          BranchInstr* branch,
+                                          Token::Kind kind,
+                                          intptr_t deopt_id,
+                                          intptr_t token_pos) {
+  ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
+  const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
+  ASSERT(ic_data.NumberOfChecks() > 0);
+  ASSERT(ic_data.num_args_tested() == 1);
+  Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
+  Register left = locs->in(0).reg();
+  Register right = locs->in(1).reg();
+  ASSERT(left == A1);
+  ASSERT(right == A0);
+  Register temp = locs->temp(0).reg();
+
+  __ TraceSimMsg("EmitEqualityAsPolymorphicCall");
+
+  LoadValueCid(compiler, temp, left,
+               (ic_data.GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
+  // 'temp' contains class-id of the left argument.
+  ObjectStore* object_store = Isolate::Current()->object_store();
+  Condition cond = TokenKindToSmiCondition(kind);
+  Label done;
+  const intptr_t len = ic_data.NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
+    // Assert that the Smi is at position 0, if at all.
+    ASSERT((ic_data.GetReceiverClassIdAt(i) != kSmiCid) || (i == 0));
+    Label next_test;
+    if (i < len - 1) {
+      __ BranchNotEqual(temp, ic_data.GetReceiverClassIdAt(i), &next_test);
+    } else {
+      __ BranchNotEqual(temp, ic_data.GetReceiverClassIdAt(i), deopt);
+    }
+    const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
+    if (target.Owner() == object_store->object_class()) {
+      // Object.== is same as ===.
+      __ Drop(2);
+      __ slt(CMPRES, left, right);
+      __ slt(TMP1, right, left);
+      if (branch != NULL) {
+        branch->EmitBranchOnCondition(compiler, cond);
+      } else {
+        Register result = locs->out().reg();
+        Label load_true;
+        EmitBranchAfterCompare(compiler, cond, &load_true);
+        __ LoadObject(result, Bool::False());
+        __ b(&done);
+        __ Bind(&load_true);
+        __ LoadObject(result, Bool::True());
+      }
+    } else {
+      const int kNumberOfArguments = 2;
+      const Array& kNoArgumentNames = Array::Handle();
+      compiler->GenerateStaticCall(deopt_id,
+                                   token_pos,
+                                   target,
+                                   kNumberOfArguments,
+                                   kNoArgumentNames,
+                                   locs);
+      if (branch == NULL) {
+        if (kind == Token::kNE) {
+          Label is_true;
+          __ CompareObject(CMPRES, TMP1, V0, Bool::True());
+          __ beq(CMPRES, TMP1, &is_true);
+          __ LoadObject(V0, Bool::True());
+          __ b(&done);
+          __ Bind(&is_true);
+          __ LoadObject(V0, Bool::False());
+        }
+      } else {
+        if (branch->is_checked()) {
+          EmitAssertBoolean(V0, token_pos, deopt_id, locs, compiler);
+        }
+        __ CompareObject(CMPRES, TMP1, V0, Bool::True());
+        branch->EmitBranchOnCondition(compiler, cond);
+      }
+    }
+    if (i < len - 1) {
+      __ b(&done);
+      __ Bind(&next_test);
+    }
+  }
+  __ Bind(&done);
+}
+
+
 // Emit code when ICData's targets are all Object == (which is ===).
 static void EmitCheckedStrictEqual(FlowGraphCompiler* compiler,
                                    const ICData& ic_data,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
                                    intptr_t deopt_id) {
   UNIMPLEMENTED();
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        LocationSummary* locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos) {
-  UNIMPLEMENTED();
-}
+  ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
+  ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
+  Register left = locs->in(0).reg();
+  Register right = locs->in(1).reg();
+  Label done, identity_compare, non_null_compare;
+  __ TraceSimMsg("EmitGenericEqualityCompare");
+  __ beq(right, NULLREG, &identity_compare);
+  __ bne(left, NULLREG, &non_null_compare);
 
-
-static Condition TokenKindToSmiCondition(Token::Kind kind) {
-  switch (kind) {
-    case Token::kEQ: return EQ;
-    case Token::kNE: return NE;
-    case Token::kLT: return LT;
-    case Token::kGT: return GT;
-    case Token::kLTE: return LE;
-    case Token::kGTE: return GE;
-    default:
-      UNREACHABLE();
-      return VS;
+  // Comparison with NULL is "===".
+  __ Bind(&identity_compare);
+  Condition cond = TokenKindToSmiCondition(kind);
+  __ slt(CMPRES, left, right);
+  __ slt(TMP1, right, left);
+  if (branch != NULL) {
+    branch->EmitBranchOnCondition(compiler, cond);
+  } else {
+    Register result = locs->out().reg();
+    Label load_true;
+    EmitBranchAfterCompare(compiler, cond, &load_true);
+    __ LoadObject(result, Bool::False());
+    __ b(&done);
+    __ Bind(&load_true);
+    __ LoadObject(result, Bool::True());
   }
-}
-
-
-// Branches on condition c assuming comparison results in CMPRES and TMP1.
-static void EmitBranchAfterCompare(
-    FlowGraphCompiler* compiler, Condition c, Label* is_true) {
-    switch (c) {
-      case EQ: __ beq(CMPRES, TMP1, is_true); break;
-      case NE: __ bne(CMPRES, TMP1, is_true); break;
-      case GT: __ bne(TMP1, ZR, is_true); break;
-      case GE: __ beq(CMPRES, ZR, is_true); break;
-      case LT: __ bne(CMPRES, ZR, is_true); break;
-      case LE: __ beq(TMP1, ZR, is_true); break;
-      default:
-        UNREACHABLE();
-        break;
-    }
+  __ b(&done);
+  __ Bind(&non_null_compare);  // Receiver is not null.
+  ASSERT(left == A1);
+  ASSERT(right == A0);
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ sw(A1, Address(SP, 1 * kWordSize));
+  __ sw(A0, Address(SP, 0 * kWordSize));
+  EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
+                                deopt_id, token_pos);
+  __ Bind(&done);
 }
 
 
 static Condition FlipCondition(Condition condition) {
-  UNIMPLEMENTED();
-  return condition;
+  switch (condition) {
+    case EQ: return EQ;
+    case NE: return NE;
+    case LT: return GT;
+    case LE: return GE;
+    case GT: return LT;
+    case GE: return LE;
+    default:
+      UNREACHABLE();
+      return EQ;
+  }
 }
 
 
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch) {
   __ TraceSimMsg("EmitSmiComparisonOp");
   Location left = locs.in(0);
   Location right = locs.in(1);
@@ skipping 74 matching lines @@
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), kNoBranch, *ic_data(),
                                deopt_id(), token_pos());
     return;
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   ASSERT(left == A1);
   ASSERT(right == A0);
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ sw(A1, Address(SP, 1 * kWordSize));
+  __ sw(A0, Address(SP, 0 * kWordSize));
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              kind(),
                              locs(),
                              *ic_data());
   ASSERT(locs()->out().reg() == V0);
 }
 
 
@@ skipping 23 matching lines @@
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), branch, *ic_data(),
                                deopt_id(), token_pos());
     return;
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   ASSERT(left == A1);
   ASSERT(right == A0);
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ sw(A1, Address(SP, 1 * kWordSize));
+  __ sw(A0, Address(SP, 0 * kWordSize));
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(V0, token_pos(), deopt_id(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
@@ skipping 178 matching lines @@
   __ LoadImmediate(A1, NativeArguments::ComputeArgcTag(function()));
   compiler->GenerateCall(token_pos(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther,
                          locs());
   __ Pop(result);
 }
 
 
 LocationSummary* StringFromCharCodeInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  // TODO(fschneider): Allow immediate operands for the char code.
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register char_code = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  __ TraceSimMsg("StringFromCharCodeInstr");
+
+  __ LoadImmediate(result,
+                   reinterpret_cast<uword>(Symbols::PredefinedAddress()));
+  __ AddImmediate(result, Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ sll(TMP1, char_code, 1);  // Char code is a smi.
+  __ addu(TMP1, TMP1, result);
+  __ lw(result, Address(TMP1));
 }
 
 
 LocationSummary* LoadUntaggedInstr::MakeLocationSummary() const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 106 matching lines @@
   if (representation() == kUnboxedDouble) {
     locs->set_out(Location::RequiresFpuRegister());
   } else {
     locs->set_out(Location::RequiresRegister());
   }
   return locs;
 }
 
 
 void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  __ TraceSimMsg("LoadIndexedInstr");
   Register array = locs()->in(0).reg();
   Location index = locs()->in(1);
 
   Address element_address(kNoRegister, 0);
   if (IsExternal()) {
     UNIMPLEMENTED();
   } else {
     ASSERT(this->array()->definition()->representation() == kTagged);
     ASSERT(index.IsRegister());  // TODO(regis): Revisit.
     // Note that index is expected smi-tagged, (i.e, times 2) for all arrays
@@ skipping 739 matching lines @@
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  locs->set_in(0, Location::RegisterLocation(T0));
+  locs->set_out(Location::RegisterLocation(T0));
+  return locs;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register context_value = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+
+  __ TraceSimMsg("CloneContextInstr");
+
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ LoadObject(TMP1, Object::ZoneHandle());  // Make room for the result.
+  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ sw(context_value, Address(SP, 0 * kWordSize));
+
+  compiler->GenerateCallRuntime(token_pos(),
+                                deopt_id(),
+                                kCloneContextRuntimeEntry,
+                                locs());
+  __ lw(result, Address(SP, 1 * kWordSize));  // Get result (cloned context).
+  __ addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 LocationSummary* CatchEntryInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
@@ skipping 78 matching lines @@
 
   __ LoadImmediate(TMP1, Isolate::Current()->stack_limit_address());
 
   __ lw(TMP1, Address(TMP1));
   __ BranchUnsignedLessEqual(SP, TMP1, slow_path->entry_label());
 
   __ Bind(slow_path->exit_label());
 }
 
 
+static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
+                             BinarySmiOpInstr* shift_left) {
+  const bool is_truncating = shift_left->is_truncating();
+  const LocationSummary& locs = *shift_left->locs();
+  Register left = locs.in(0).reg();
+  Register result = locs.out().reg();
+  Label* deopt = shift_left->CanDeoptimize() ?
+      compiler->AddDeoptStub(shift_left->deopt_id(), kDeoptBinarySmiOp) : NULL;
+
+  __ TraceSimMsg("EmitSmiShiftLeft");
+
+  if (locs.in(1).IsConstant()) {
+    const Object& constant = locs.in(1).constant();
+    ASSERT(constant.IsSmi());
+    // Immediate shift operation takes 5 bits for the count.
+    const intptr_t kCountLimit = 0x1F;
+    const intptr_t value = Smi::Cast(constant).Value();
+    if (value == 0) {
+      // No code needed.
+    } else if ((value < 0) || (value >= kCountLimit)) {
+      // This condition may not be known earlier in some cases because
+      // of constant propagation, inlining, etc.
+      if ((value >= kCountLimit) && is_truncating) {
+        __ mov(result, ZR);
+      } else {
+        // Result is Mint or exception.
+        __ b(deopt);
+      }
+    } else {
+      if (!is_truncating) {
+        // Check for overflow (preserve left).
+        __ sll(TMP1, left, value);
+        __ sra(TMP1, TMP1, value);
+        __ bne(TMP1, left, deopt);  // Overflow.
+      }
+      // Shift for result now we know there is no overflow.
+      __ sll(result, left, value);
+    }
+    return;
+  }
+
+  // Right (locs.in(1)) is not constant.
+  Register right = locs.in(1).reg();
+  Range* right_range = shift_left->right()->definition()->range();
+  if (shift_left->left()->BindsToConstant() && !is_truncating) {
+    // TODO(srdjan): Implement code below for is_truncating().
+    // If left is constant, we know the maximal allowed size for right.
+    const Object& obj = shift_left->left()->BoundConstant();
+    if (obj.IsSmi()) {
+      const intptr_t left_int = Smi::Cast(obj).Value();
+      if (left_int == 0) {
+        __ bltz(right, deopt);
+        return;
+      }
+      const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
+      const bool right_needs_check =
+          (right_range == NULL) ||
+          !right_range->IsWithin(0, max_right - 1);
+      if (right_needs_check) {
+        __ BranchUnsignedGreaterEqual(
+            right, reinterpret_cast<int32_t>(Smi::New(max_right)), deopt);
+      }
+      __ SmiUntag(right);
+      __ sllv(result, left, right);
+    }
+    return;
+  }
+
+  const bool right_needs_check =
+      (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
+  if (is_truncating) {
+    if (right_needs_check) {
+      const bool right_may_be_negative =
+          (right_range == NULL) ||
+          !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
+      if (right_may_be_negative) {
+        ASSERT(shift_left->CanDeoptimize());
+        __ bltz(right, deopt);
+      }
+      Label done, is_not_zero;
+
+      __ sltiu(CMPRES,
+          right, Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
+      __ movz(result, ZR, CMPRES);  // result = right >= kBits ? 0 : result.
+      __ mov(TMP1, right);
+      __ SmiUntag(TMP1);
+      __ sllv(TMP1, left, TMP1);
+      // result = right < kBits ? left << right : result.
+      __ movn(result, TMP1, CMPRES);
+    } else {
+      __ SmiUntag(right);
+      __ sllv(result, left, right);
+    }
+  } else {
+    if (right_needs_check) {
+      ASSERT(shift_left->CanDeoptimize());
+      __ BranchUnsignedGreaterEqual(
+          right, reinterpret_cast<int32_t>(Smi::New(Smi::kBits)), deopt);
+    }
+    // Left is not a constant.
+    // Check if count too large for handling it inlined.
+    __ SmiUntag(right);
+    // Overflow test (preserve left and right);
+    __ sllv(TMP1, left, right);
+    __ srav(TMP1, TMP1, right);
+    __ bne(TMP1, left, deopt);  // Overflow.
+    // Shift for result now we know there is no overflow.
+    __ sllv(result, left, right);
+  }
+}
+
+
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (op_kind() == Token::kTRUNCDIV) {
     UNIMPLEMENTED();
     return NULL;
   } else {
     const intptr_t kNumTemps = op_kind() == Token::kADD ? 1 : 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterOrSmiConstant(right()));
     if (op_kind() == Token::kADD) {
       // Need an extra temp for the overflow detection code.
       summary->set_temp(0, Location::RequiresRegister());
     }
     // We make use of 3-operand instructions by not requiring result register
     // to be identical to first input register as on Intel.
     summary->set_out(Location::RequiresRegister());
     return summary;
   }
 }
 
 
 void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("BinarySmiOpInstr");
   if (op_kind() == Token::kSHL) {
-    UNIMPLEMENTED();
+    EmitSmiShiftLeft(compiler, this);
     return;
   }
 
   ASSERT(!is_truncating());
   Register left = locs()->in(0).reg();
   Register result = locs()->out().reg();
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     int32_t imm = reinterpret_cast<int32_t>(constant.raw());
     switch (op_kind()) {
       case Token::kSUB: {
+        __ TraceSimMsg("kSUB imm");
         if (deopt == NULL) {
           __ AddImmediate(result, left, -imm);
         } else {
           __ SubImmediateDetectOverflow(result, left, imm, CMPRES);
           __ bltz(CMPRES, deopt);
         }
         break;
       }
       case Token::kADD: {
         if (deopt == NULL) {
@@ skipping 59 matching lines @@
         // No overflow check.
         if (Utils::IsUint(kImmBits, imm)) {
           __ xori(result, left, Immediate(imm));
         } else {
           __ LoadImmediate(TMP1, imm);
           __ xor_(result, left, TMP1);
         }
         break;
       }
       case Token::kSHR: {
-        UNIMPLEMENTED();
+        // sarl operation masks the count to 5 bits.
+        const intptr_t kCountLimit = 0x1F;
+        intptr_t value = Smi::Cast(constant).Value();
+
+        __ TraceSimMsg("kSHR");
+
+        if (value == 0) {
+          // TODO(vegorov): should be handled outside.
+          __ break_(0);
+          break;
+        } else if (value < 0) {
+          // TODO(vegorov): should be handled outside.
+          __ b(deopt);
+          break;
+        }
+
+        value = value + kSmiTagSize;
+        if (value >= kCountLimit) value = kCountLimit;
+
+        __ sra(result, left, value);
+        __ SmiTag(result);
         break;
       }
 
       default:
         UNREACHABLE();
         break;
     }
     return;
   }
 
   Register right = locs()->in(1).reg();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
         __ addu(result, left, right);
       } else {
         Register temp = locs()->temp(0).reg();
         __ AdduDetectOverflow(result, left, right, CMPRES, temp);
         __ bltz(CMPRES, deopt);
       }
       break;
     }
     case Token::kSUB: {
+      __ TraceSimMsg("kSUB");
       if (deopt == NULL) {
         __ subu(result, left, right);
       } else {
         __ SubuDetectOverflow(result, left, right, CMPRES);
         __ bltz(CMPRES, deopt);
       }
       break;
     }
     case Token::kMUL: {
+      __ TraceSimMsg("kMUL");
       __ SmiUntag(left);
       __ mult(left, right);
       __ mflo(result);
       if (deopt != NULL) {
-        UNIMPLEMENTED();
+        __ mfhi(TMP1);
+        __ sra(CMPRES, result, 31);
+        __ bne(TMP1, CMPRES, deopt);
       }
       break;
     }
     case Token::kBIT_AND: {
       // No overflow check.
       __ and_(result, left, right);
       break;
     }
     case Token::kBIT_OR: {
       // No overflow check.
@@ skipping 411 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("PolymorphicInstanceCallInstr");
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptPolymorphicInstanceCallTestFail);
+  __ TraceSimMsg("PolymorphicInstanceCallInstr");
   if (ic_data().NumberOfChecks() == 0) {
     __ b(deopt);
     return;
   }
   ASSERT(ic_data().num_args_tested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
@@ skipping 361 matching lines @@
   } else {
     compiler->EmitEqualityRegRegCompare(left.reg(),
                                        right.reg(),
                                        needs_number_check(),
                                        token_pos());
   }
 
   Register result = locs()->out().reg();
   Label load_true, done;
   if (kind() == Token::kEQ_STRICT) {
-    __ beq(CMPRES, ZR, &load_true);
+    __ beq(CMPRES, TMP1, &load_true);
   } else {
     ASSERT(kind() == Token::kNE_STRICT);
-    __ bne(CMPRES, ZR, &load_true);
+    __ bne(CMPRES, TMP1, &load_true);
   }
   __ LoadObject(result, Bool::False());
   __ b(&done);
   __ Bind(&load_true);
   __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
@@ skipping 127 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS