Implements context allocation stub for 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 701 matching lines @@
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
 
   // Push arguments for the call.
   // TODO(fschneider): Split this instruction into different types to avoid
   // explicitly pushing arguments to the call here.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
-  __ Push(left);
-  __ Push(right);
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ sw(left, Address(SP, 1 * kWordSize));
+  __ sw(right, Address(SP, 0 * kWordSize));
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptRelationalOp);
     // Load class into A2.
     const intptr_t kNumArguments = 2;
     LoadValueCid(compiler, A2, left);
     compiler->EmitTestAndCall(ICData::Handle(ic_data()->AsUnaryClassChecks()),
                               A2,  // Class id register.
                               kNumArguments,
                               Array::Handle(),  // No named arguments.
                               deopt,  // Deoptimize target.
@@ skipping 409 matching lines @@
     }
   }
 
   if (deopt == NULL) {
     ASSERT(!compiler->is_optimizing());
     __ Bind(fail);
 
     __ lw(TMP1, FieldAddress(field_reg, Field::guarded_cid_offset()));
     __ BranchEqual(TMP1, kDynamicCid, &ok);
 
-    __ Push(field_reg);
-    __ Push(value_reg);
+    __ addiu(SP, SP, Immediate(-2 * kWordSize));
+    __ sw(field_reg, Address(SP, 1 * kWordSize));
+    __ sw(value_reg, Address(SP, 0 * kWordSize));
     __ CallRuntime(kUpdateFieldCidRuntimeEntry);
     __ Drop(2);  // Drop the field and the value.
   }
 
   __ Bind(&ok);
 }
 
 
 LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
@@ skipping 172 matching lines @@
     // because a null instantiator will have the wrong class (Null instead of
     // TypeArguments).
     Label type_arguments_uninstantiated;
     __ LoadClassId(temp, instantiator_reg);
     __ BranchNotEqual(temp, kTypeArgumentsCid, &type_arguments_uninstantiated);
     __ lw(temp, FieldAddress(instantiator_reg, TypeArguments::length_offset()));
     __ BranchEqual(temp, Smi::RawValue(len), &type_arguments_instantiated);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required.
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ PushObject(type_arguments());
-  __ Push(instantiator_reg);  // Push instantiator type arguments.
+  __ addiu(SP, SP, Immediate(-3 * kWordSize));
+  __ LoadObject(TMP1, Object::ZoneHandle());
+  __ LoadObject(TMP2, type_arguments());
+  __ sw(TMP1, Address(SP, 2 * kWordSize));  // Make room for the result.
+  __ sw(TMP2, Address(SP, 1 * kWordSize));
+  // Push instantiator type arguments.
+  __ sw(instantiator_reg, Address(SP, 0 * kWordSize));
+
   compiler->GenerateCallRuntime(token_pos(),
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 locs());
-  __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
-  __ Pop(result_reg);  // Pop instantiated type arguments.
+  // Pop instantiated type arguments.
+  __ lw(result_reg, Address(SP, 2 * kWordSize));
+  // Drop instantiator and uninstantiated type arguments.
+  __ addiu(SP, SP, Immediate(3 * kWordSize));
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
 LocationSummary*
 ExtractConstructorTypeArgumentsInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
@@ skipping 108 matching lines @@
     // instantiated type arguments, no proper instantiator needed.
     __ LoadImmediate(instantiator_reg,
                      Smi::RawValue(StubCode::kNoInstantiator));
   }
   __ Bind(&done);
   // instantiator_reg: instantiator or kNoInstantiator.
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary() const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  locs->set_temp(0, Location::RegisterLocation(T1));
+  locs->set_out(Location::RegisterLocation(V0));
+  return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register temp = T1;
+  ASSERT(locs()->temp(0).reg() == temp);
+  ASSERT(locs()->out().reg() == V0);
+
+  __ TraceSimMsg("AllocateContextInstr");
+  __ LoadImmediate(temp, num_context_variables());
+  const ExternalLabel label("alloc_context",
+                            StubCode::AllocateContextEntryPoint());
+  compiler->GenerateCall(token_pos(),
+                         &label,
+                         PcDescriptors::kOther,
+                         locs());
 }
 
 
 LocationSummary* CloneContextInstr::MakeLocationSummary() const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 855 matching lines @@
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS