Supports FrameLookup vm test on MIPS

runtime/vm/flow_graph_compiler_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/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 31 matching lines @@
 
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   UNIMPLEMENTED();
 }
 
 
 #define __ assembler()->
 
 
+// Fall through if bool_register contains null.
 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
                                            Label* is_true,
                                            Label* is_false) {
-  UNIMPLEMENTED();
+  Label fall_through;
+  __ BranchEqual(bool_register, reinterpret_cast<intptr_t>(Object::null()),
+                 &fall_through);
+  __ BranchEqual(bool_register, Bool::True(), is_true);
+  __ b(is_false);
+  __ Bind(&fall_through);
 }
 
 
+// A0: instance (must be preserved).
+// A1: instantiator type arguments (if used).
 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
     TypeTestStubKind test_kind,
     Register instance_reg,
     Register type_arguments_reg,
     Register temp_reg,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
-  UNIMPLEMENTED();
-  return NULL;
+  ASSERT(instance_reg == A0);
+  ASSERT(temp_reg == kNoRegister);  // Unused on MIPS.
+  const SubtypeTestCache& type_test_cache =
+      SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
+  __ LoadObject(A2, type_test_cache);
+  if (test_kind == kTestTypeOneArg) {
+    ASSERT(type_arguments_reg == kNoRegister);
+    __ LoadImmediate(A1, reinterpret_cast<intptr_t>(Object::null()));
+    __ BranchLink(&StubCode::Subtype1TestCacheLabel());
+  } else if (test_kind == kTestTypeTwoArgs) {
+    ASSERT(type_arguments_reg == kNoRegister);
+    __ LoadImmediate(A1, reinterpret_cast<intptr_t>(Object::null()));
+    __ BranchLink(&StubCode::Subtype2TestCacheLabel());
+  } else if (test_kind == kTestTypeThreeArgs) {
+    ASSERT(type_arguments_reg == A1);
+    __ BranchLink(&StubCode::Subtype3TestCacheLabel());
+  } else {
+    UNREACHABLE();
+  }
+  // Result is in V0: null -> not found, otherwise Bool::True or Bool::False.
+  GenerateBoolToJump(V0, is_instance_lbl, is_not_instance_lbl);
+  return type_test_cache.raw();
 }
 
 
 RawSubtypeTestCache*
 FlowGraphCompiler::GenerateInstantiatedTypeWithArgumentsTest(
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   UNIMPLEMENTED();
@@ skipping 68 matching lines @@
   }
   if (type.IsStringType()) {
     GenerateStringTypeCheck(kClassIdReg, is_instance_lbl, is_not_instance_lbl);
     return false;
   }
   // Otherwise fallthrough.
   return true;
 }
 
 
+// Uses SubtypeTestCache to store instance class and result.
+// A0: instance to test.
+// Clobbers A1, A2, T0-T3.
+// Immediate class test already done.
+// TODO(srdjan): Implement a quicker subtype check, as type test
+// arrays can grow too high, but they may be useful when optimizing
+// code (type-feedback).
 RawSubtypeTestCache* FlowGraphCompiler::GenerateSubtype1TestCacheLookup(
     intptr_t token_pos,
     const Class& type_class,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
-  UNIMPLEMENTED();
-  return NULL;
+  __ Comment("Subtype1TestCacheLookup");
+  const Register kInstanceReg = A0;
+  __ LoadClass(T0, kInstanceReg);
+  // T0: instance class.
+  // Check immediate superclass equality.
+  __ lw(T0, FieldAddress(T0, Class::super_type_offset()));
+  __ lw(T0, FieldAddress(T0, Type::type_class_offset()));
+  __ BranchEqual(T0, type_class, is_instance_lbl);
+
+  const Register kTypeArgumentsReg = kNoRegister;
+  const Register kTempReg = kNoRegister;
+  return GenerateCallSubtypeTestStub(kTestTypeOneArg,
+                                     kInstanceReg,
+                                     kTypeArgumentsReg,
+                                     kTempReg,
+                                     is_instance_lbl,
+                                     is_not_instance_lbl);
 }
 
 
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   UNIMPLEMENTED();
   return NULL;
@@ skipping 149 matching lines @@
   __ lw(A2, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ Push(A0);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   // Push instantiator and its type arguments.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(A2, Address(SP, 1 * kWordSize));
   __ sw(A1, Address(SP, 0 * kWordSize));
   __ PushObject(dst_name);  // Push the name of the destination.
-  __ LoadObject(A0, test_cache);
-  __ Push(A0);
+  __ LoadObject(T0, test_cache);
+  __ Push(T0);
   GenerateCallRuntime(token_pos, deopt_id, kTypeCheckRuntimeEntry, locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
   __ Pop(A0);
 
   __ Bind(&is_assignable);
   // Restore instantiator and its type arguments.
   __ lw(A1, Address(SP, 0 * kWordSize));
   __ lw(A2, Address(SP, 1 * kWordSize));
@@ skipping 54 matching lines @@
   // Argument i passed at fp[kLastParamSlotIndex + num_args - 1 - i] is copied
   // to fp[kFirstLocalSlotIndex - i].
 
   __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   // Since T1 and T2 are Smi, use sll 1 instead of sll 2.
   // Let T1 point to the last passed positional argument, i.e. to
   // fp[kLastParamSlotIndex + num_args - 1 - (num_pos_args - 1)].
   __ subu(T1, T1, T2);
   __ sll(T1, T1, 1);
   __ addu(T1, FP, T1);
-  __ addiu(T1, T1, Immediate(kLastParamSlotIndex * kWordSize));
+  __ AddImmediate(T1, kLastParamSlotIndex * kWordSize);
 
   // Let T0 point to the last copied positional argument, i.e. to
   // fp[kFirstLocalSlotIndex - (num_pos_args - 1)].
-  __ addiu(T0, FP, Immediate((kFirstLocalSlotIndex + 1) * kWordSize));
+  __ AddImmediate(T0, FP, (kFirstLocalSlotIndex + 1) * kWordSize);
   __ sll(T3, T2, 1);  // T2 is a Smi.
   __ subu(T0, T0, T3);
 
   Label loop, loop_condition;
   __ b(&loop_condition);
   __ delay_slot()->SmiUntag(T2);
   // We do not use the final allocation index of the variable here, i.e.
   // scope->VariableAt(i)->index(), because captured variables still need
   // to be copied to the context that is not yet allocated.
   __ Bind(&loop);
@@ skipping 27 matching lines @@
       opt_param_position[i + 1] = pos;
     }
     // Generate code handling each optional parameter in alphabetical order.
     __ lw(T1, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
     __ lw(T2, FieldAddress(S4, ArgumentsDescriptor::positional_count_offset()));
     __ SmiUntag(T2);
     // Let T1 point to the first passed argument, i.e. to
     // fp[kLastParamSlotIndex + num_args - 1 - 0]; num_args (T1) is Smi.
     __ sll(T3, T1, 1);
     __ addu(T1, FP, T3);
-    __ addiu(T1, T1, Immediate((kLastParamSlotIndex - 1) * kWordSize));
+    __ AddImmediate(T1, (kLastParamSlotIndex - 1) * kWordSize);
     // Let T0 point to the entry of the first named argument.
-    __ addiu(T0, S4, Immediate(
-        ArgumentsDescriptor::first_named_entry_offset() - kHeapObjectTag));
+    __ AddImmediate(T0, S4,
+        ArgumentsDescriptor::first_named_entry_offset() - kHeapObjectTag);
     for (int i = 0; i < num_opt_named_params; i++) {
       Label load_default_value, assign_optional_parameter;
       const int param_pos = opt_param_position[i];
       // Check if this named parameter was passed in.
       // Load T3 with the name of the argument.
       __ lw(T3, Address(T0, ArgumentsDescriptor::name_offset()));
       ASSERT(opt_param[i]->name().IsSymbol());
       __ BranchNotEqual(T3, opt_param[i]->name(), &load_default_value);
 
       // Load T3 with passed-in argument at provided arg_pos, i.e. at
       // fp[kLastParamSlotIndex + num_args - 1 - arg_pos].
       __ lw(T3, Address(T0, ArgumentsDescriptor::position_offset()));
       // T3 is arg_pos as Smi.
       // Point to next named entry.
-      __ addiu(T0, T0, Immediate(ArgumentsDescriptor::named_entry_size()));
+      __ AddImmediate(T0, ArgumentsDescriptor::named_entry_size());
       __ subu(T3, ZR, T3);
       __ sll(T3, T3, 1);
       __ addu(T3, T1, T3);
       __ b(&assign_optional_parameter);
       __ delay_slot()->lw(T3, Address(T3));
 
       __ Bind(&load_default_value);
       // Load T3 with default argument.
       const Object& value = Object::ZoneHandle(
           parsed_function().default_parameter_values().At(
@@ skipping 41 matching lines @@
     __ SmiUntag(T1);
     // Check that T2 equals T1, i.e. no named arguments passed.
     __ beq(T2, T1, &all_arguments_processed);
   }
 
   __ Bind(&wrong_num_arguments);
   if (StackSize() != 0) {
     // We need to unwind the space we reserved for locals and copied parameters.
     // The NoSuchMethodFunction stub does not expect to see that area on the
     // stack.
-    __ addiu(SP, SP, Immediate(StackSize() * kWordSize));
+    __ AddImmediate(SP, StackSize() * kWordSize);
   }
   // The call below has an empty stackmap because we have just
   // dropped the spill slots.
   BitmapBuilder* empty_stack_bitmap = new BitmapBuilder();
 
   // Invoke noSuchMethod function passing the original name of the function.
   // If the function is a closure function, use "call" as the original name.
   const String& name = String::Handle(
       function.IsClosureFunction() ? Symbols::Call().raw() : function.name());
   const int kNumArgsChecked = 1;
@@ skipping 172 matching lines @@
 
       __ lw(T1, FieldAddress(S4,
                              ArgumentsDescriptor::positional_count_offset()));
       __ beq(T0, T1, &correct_num_arguments);
       __ Bind(&wrong_num_arguments);
       if (function.IsClosureFunction()) {
         if (StackSize() != 0) {
           // We need to unwind the space we reserved for locals and copied
           // parameters. The NoSuchMethodFunction stub does not expect to see
           // that area on the stack.
-          __ addiu(SP, SP, Immediate(StackSize() * kWordSize));
+          __ AddImmediate(SP, StackSize() * kWordSize);
         }
         // The call below has an empty stackmap because we have just
         // dropped the spill slots.
         BitmapBuilder* empty_stack_bitmap = new BitmapBuilder();
 
         // Invoke noSuchMethod function passing "call" as the function name.
         const int kNumArgsChecked = 1;
         const ICData& ic_data = ICData::ZoneHandle(
             ICData::New(function, Symbols::Call(),
                         Isolate::kNoDeoptId, kNumArgsChecked));
@@ skipping 107 matching lines @@
                          deopt_id,
                          token_pos);
   }
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t token_pos,
                                             intptr_t deopt_id,
                                             const RuntimeEntry& entry,
                                             LocationSummary* locs) {
-  __ Unimplemented("call runtime");
+  __ CallRuntime(entry);
+  AddCurrentDescriptor(PcDescriptors::kOther, deopt_id, token_pos);
+  RecordSafepoint(locs);
+  if (deopt_id != Isolate::kNoDeoptId) {
+    // Marks either the continuation point in unoptimized code or the
+    // deoptimization point in optimized code, after call.
+    if (is_optimizing()) {
+      AddDeoptIndexAtCall(deopt_id, token_pos);
+    } else {
+      // Add deoptimization continuation point after the call and before the
+      // arguments are removed.
+      AddCurrentDescriptor(PcDescriptors::kDeoptAfter,
+                           deopt_id,
+                           token_pos);
+    }
+  }
 }
 
 
 void FlowGraphCompiler::EmitOptimizedInstanceCall(
     ExternalLabel* target_label,
     const ICData& ic_data,
     const Array& arguments_descriptor,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
@@ skipping 53 matching lines @@
 void FlowGraphCompiler::EmitEqualityRegConstCompare(Register reg,
                                                     const Object& obj,
                                                     bool needs_number_check) {
   UNIMPLEMENTED();
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
                                                   Register right,
                                                   bool needs_number_check) {
-  UNIMPLEMENTED();
+  if (needs_number_check) {
+    __ Push(left);
+    __ Push(right);
+    __ BranchLink(&StubCode::IdenticalWithNumberCheckLabel());
+    // Stub returns result in CMPRES. If it is 0, then left and right are equal.
+    __ Pop(right);
+    __ Pop(left);
+  } else {
+    __ subu(CMPRES, left, right);
+  }
 }
 
 
 void FlowGraphCompiler::EmitSuperEqualityCallPrologue(Register result,
                                                       Label* skip_call) {
   UNIMPLEMENTED();
 }
 
 
 void FlowGraphCompiler::SaveLiveRegisters(LocationSummary* locs) {
@@ skipping 170 matching lines @@
 
 
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS