Adds support for debugger API on MIPS.

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 81 matching lines @@
         (kFirstLocalSlotIndex + 1 - compiler->StackSize()) * kWordSize;
     ASSERT(fp_sp_dist <= 0);
     __ subu(T2, SP, FP);
 
     __ BranchEqual(T2, fp_sp_dist, &stack_ok);
     __ break_(0);
 
     __ Bind(&stack_ok);
   }
 #endif
+  // This sequence is patched by a debugger breakpoint. There is no need for
+  // extra NOP instructions here because the sequence patched in for a
+  // breakpoint is shorter than the sequence here.
   __ LeaveDartFrame();
   __ Ret();
-
-  // Generate 2 NOP instructions so that the debugger can patch the return
-  // pattern (1 instruction) with a call to the debug stub (3 instructions).
-  __ nop();
-  __ nop();
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  Isolate::kNoDeoptId,
                                  token_pos());
 }
 
 
 bool IfThenElseInstr::IsSupported() {
   return false;
 }
 
@@ skipping 1556 matching lines @@
           __ AddImmediate(result, left, imm);
         } else {
           __ AddImmediateDetectOverflow(result, left, imm, CMPRES);
           __ bltz(CMPRES, deopt);
         }
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
-        if (value == 2) {
-          __ sll(result, left, 1);
+        if (deopt == NULL) {
+          if (value == 2) {
+            __ sll(result, left, 1);
+          } else {
+            __ LoadImmediate(TMP1, value);
+            __ mult(left, TMP1);
+            __ mflo(result);
+          }
         } else {
-          __ LoadImmediate(TMP1, value);
-          __ mult(left, TMP1);
-          __ mflo(result);
-        }
-        if (deopt != NULL) {
-          UNIMPLEMENTED();
+          if (value == 2) {
+            __ sra(TMP1, left, 31);  // TMP1 = sign of left.
+            __ sll(result, left, 1);
+          } else {
+            __ LoadImmediate(TMP1, value);
+            __ mult(left, TMP1);
+            __ mflo(result);
+            __ mfhi(TMP1);
+          }
+          __ sra(TMP2, result, 31);
+          __ bne(TMP1, TMP2, deopt);
         }
         break;
       }
       case Token::kTRUNCDIV: {
         UNIMPLEMENTED();
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
         if (Utils::IsUint(kImmBits, imm)) {
@@ skipping 668 matching lines @@
   Register result = locs()->out().reg();
 
   __ LoadObject(result, Bool::True());
   __ LoadObject(TMP1, Bool::False());
   __ subu(CMPRES, value, result);
   __ movz(result, TMP1, CMPRES);  // If value is True, move False into result.
 }
 
 
 LocationSummary* ChainContextInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  return LocationSummary::Make(1,
+                               Location::NoLocation(),
+                               LocationSummary::kNoCall);
 }
 
 
 void ChainContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register context_value = locs()->in(0).reg();
+
+  // Chain the new context in context_value to its parent in CTX.
+  __ StoreIntoObject(context_value,
+                     FieldAddress(context_value, Context::parent_offset()),
+                     CTX);
+  // Set new context as current context.
+  __ mov(CTX, context_value);
 }
 
 
 LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
+                                              : Location::RequiresRegister());
+  locs->set_in(1, Location::RequiresRegister());
+  return locs;
 }
 
 
 void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register value_reg = locs()->in(0).reg();
+  Register dest_reg = locs()->in(1).reg();
+
+  if (value()->NeedsStoreBuffer()) {
+    __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
+                       value_reg);
+  } else {
+    __ StoreIntoObjectNoBarrier(
+        dest_reg, FieldAddress(dest_reg, offset_in_bytes()), value_reg);
+  }
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ TraceSimMsg("AllocateObjectInstr");
@@ skipping 23 matching lines @@
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS