Enables more VM tests for SIMMIPS.

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 369 matching lines @@
 }
 
 
 // Generates inlined check if 'type' is a type parameter or type itself
 // A0: instance (preserved).
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
+  __ TraceSimMsg("UninstantiatedTypeTest");
   __ Comment("UninstantiatedTypeTest");
   ASSERT(!type.IsInstantiated());
   // Skip check if destination is a dynamic type.
   if (type.IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(type);
     // Load instantiator (or null) and instantiator type arguments on stack.
     __ lw(A1, Address(SP, 0));  // Get instantiator type arguments.
     // A1: instantiator type arguments.
     // Check if type argument is dynamic.
     __ beq(A1, NULLREG, is_instance_lbl);
@@ skipping 310 matching lines @@
   __ subu(T1, T1, T2);
   __ sll(T1, T1, 1);
   __ addu(T1, FP, T1);
   __ AddImmediate(T1, (kParamEndSlotFromFp + 1) * kWordSize);
 
   // Let T0 point to the last copied positional argument, i.e. to
   // fp[kFirstLocalSlotFromFp - (num_pos_args - 1)].
   __ AddImmediate(T0, FP, (kFirstLocalSlotFromFp + 1) * kWordSize);
   __ sll(T2, T2, 1);  // T2 is a Smi.
 
+  __ Comment("Argument Copy Loop");
   Label loop, loop_exit;
   __ blez(T2, &loop_exit);
   __ delay_slot()->subu(T0, T0, T2);
   __ Bind(&loop);
   __ addu(T4, T1, T2);
   __ lw(T3, Address(T4, -kWordSize));
   __ addiu(T2, T2, Immediate(-kWordSize));
   __ addu(T5, T0, T2);
   __ bgtz(T2, &loop);
   __ delay_slot()->sw(T3, Address(T5));
   __ Bind(&loop_exit);
 
   // Copy or initialize optional named arguments.
   Label all_arguments_processed;
   if (num_opt_named_params > 0) {
+    __ Comment("There are named parameters");
     // Start by alphabetically sorting the names of the optional parameters.
     LocalVariable** opt_param = new LocalVariable*[num_opt_named_params];
     int* opt_param_position = new int[num_opt_named_params];
     for (int pos = num_fixed_params; pos < num_params; pos++) {
       LocalVariable* parameter = scope->VariableAt(pos);
       const String& opt_param_name = parameter->name();
       int i = pos - num_fixed_params;
       while (--i >= 0) {
         LocalVariable* param_i = opt_param[i];
         const intptr_t result = opt_param_name.CompareTo(param_i->name());
@@ skipping 52 matching lines @@
       const intptr_t computed_param_pos = kFirstLocalSlotFromFp - param_pos;
       __ sw(T3, Address(FP, computed_param_pos * kWordSize));
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that T0 now points to the null terminator in the array descriptor.
     __ lw(T3, Address(T0));
     __ beq(T3, NULLREG, &all_arguments_processed);
   } else {
     ASSERT(num_opt_pos_params > 0);
+    __ Comment("There are optional positional parameters");
     __ lw(T2,
           FieldAddress(S4, ArgumentsDescriptor::positional_count_offset()));
     __ SmiUntag(T2);
     for (int i = 0; i < num_opt_pos_params; i++) {
       Label next_parameter;
       // Handle this optional positional parameter only if k or fewer positional
       // arguments have been passed, where k is param_pos, the position of this
       // optional parameter in the formal parameter list.
       const int param_pos = num_fixed_params + i;
       __ BranchSignedGreater(T2, param_pos, &next_parameter);
@@ skipping 58 matching lines @@
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
   // This step can be skipped in case we decide that formal parameters are
   // implicitly final, since garbage collecting the unmodified value is not
   // an issue anymore.
 
   // S4 : arguments descriptor array.
   __ lw(T2, FieldAddress(S4, ArgumentsDescriptor::count_offset()));
   __ sll(T2, T2, 1);  // T2 is a Smi.
 
+  __ Comment("Null arguments loop");
   Label null_args_loop, null_args_loop_exit;
   __ blez(T2, &null_args_loop_exit);
   __ delay_slot()->addiu(T1, FP,
                          Immediate((kParamEndSlotFromFp + 1) * kWordSize));
   __ Bind(&null_args_loop);
   __ addiu(T2, T2, Immediate(-kWordSize));
   __ addu(T3, T1, T2);
   __ bgtz(T2, &null_args_loop);
   __ delay_slot()->sw(NULLREG, Address(T3));
   __ Bind(&null_args_loop_exit);
@@ skipping 17 matching lines @@
   // Sequence node has one store node and one return NULL node.
   __ lw(T0, Address(SP, 1 * kWordSize));  // Receiver.
   __ lw(T1, Address(SP, 0 * kWordSize));  // Value.
   __ StoreIntoObject(T0, FieldAddress(T0, offset), T1);
   __ Ret();
   __ delay_slot()->mov(V0, NULLREG);
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
-  __ TraceSimMsg("FrameEntry");
   const Function& function = parsed_function().function();
   if (CanOptimizeFunction() && function.is_optimizable()) {
     const bool can_optimize = !is_optimizing() || may_reoptimize();
     const Register function_reg = T0;
     if (can_optimize) {
       Label next;
       // The pool pointer is not setup before entering the Dart frame.
 
       __ mov(TMP1, RA);  // Save RA.
       __ bal(&next);  // Branch and link to next instruction to get PC in RA.
@@ skipping 204 matching lines @@
                        Isolate::kNoDeoptId,
                        0);  // No token position.
   __ Branch(&StubCode::DeoptimizeLazyLabel());
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
                                      LocationSummary* locs) {
-  __ TraceSimMsg("Call");
   __ BranchLinkPatchable(label);
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::GenerateDartCall(intptr_t deopt_id,
                                          intptr_t token_pos,
                                          const ExternalLabel* label,
                                          PcDescriptors::Kind kind,
                                          LocationSummary* locs) {
-  __ TraceSimMsg("DartCall");
   __ BranchLinkPatchable(label);
   AddCurrentDescriptor(kind, deopt_id, token_pos);
   RecordSafepoint(locs);
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Isolate::ToDeoptAfter(deopt_id);
   if (is_optimizing()) {
     AddDeoptIndexAtCall(deopt_id_after, token_pos);
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
     AddCurrentDescriptor(PcDescriptors::kDeopt,
                          deopt_id_after,
                          token_pos);
   }
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t token_pos,
                                             intptr_t deopt_id,
                                             const RuntimeEntry& entry,
                                             LocationSummary* locs) {
-  __ TraceSimMsg("CallRuntime");
   __ 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.
     const intptr_t deopt_id_after = Isolate::ToDeoptAfter(deopt_id);
     if (is_optimizing()) {
       AddDeoptIndexAtCall(deopt_id_after, token_pos);
     } else {
       // Add deoptimization continuation point after the call and before the
       // arguments are removed.
       AddCurrentDescriptor(PcDescriptors::kDeopt,
                            deopt_id_after,
                            token_pos);
     }
   }
-  __ TraceSimMsg("CallRuntime return");
 }
 
 
 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,
     LocationSummary* locs) {
   // Each ICData propagated from unoptimized to optimized code contains the
   // function that corresponds to the Dart function of that IC call. Due
   // to inlining in optimized code, that function may not correspond to the
   // top-level function (parsed_function().function()) which could be
   // reoptimized and which counter needs to be incremented.
   // Pass the function explicitly, it is used in IC stub.
+  __ TraceSimMsg("OptimizedInstanceCall");
   __ LoadObject(T0, parsed_function().function());
   __ LoadObject(S4, arguments_descriptor);
   __ LoadObject(S5, ic_data);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    PcDescriptors::kIcCall,
                    locs);
   __ Drop(argument_count);
 }
@@ skipping 19 matching lines @@
 }
 
 
 void FlowGraphCompiler::EmitMegamorphicInstanceCall(
     const ICData& ic_data,
     const Array& arguments_descriptor,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
-  UNIMPLEMENTED();
+  MegamorphicCacheTable* table = Isolate::Current()->megamorphic_cache_table();
+  const String& name = String::Handle(ic_data.target_name());
+  const MegamorphicCache& cache =
+      MegamorphicCache::ZoneHandle(table->Lookup(name, arguments_descriptor));
+  Label not_smi, load_cache;
+  __ TraceSimMsg("MegamorphicInstanceCall");
+  __ lw(T0, Address(SP, (argument_count - 1) * kWordSize));
+  __ andi(CMPRES, T0, Immediate(kSmiTagMask));
+  __ bne(CMPRES, ZR, &not_smi);
+  __ LoadImmediate(T0, Smi::RawValue(kSmiCid));
+  __ b(&load_cache);
+
+  __ Bind(&not_smi);
+  __ LoadClassId(T0, T0);
+  __ SmiTag(T0);
+
+  // T0: class ID of the receiver (smi).
+  __ Bind(&load_cache);
+  __ LoadObject(T1, cache);
+  __ lw(T2, FieldAddress(T1, MegamorphicCache::buckets_offset()));
+  __ lw(T1, FieldAddress(T1, MegamorphicCache::mask_offset()));
+  // T2: cache buckets array.
+  // T1: mask.
+  __ mov(T3, T0);
+
+  Label loop, update, call_target_function;
+  __ b(&loop);
+
+  __ Bind(&update);
+  __ addiu(T3, T3, Immediate(Smi::RawValue(1)));
+  __ Bind(&loop);
+  __ and_(T3, T3, T1);
+  const intptr_t base = Array::data_offset();
+  // T3 is smi tagged, but table entries are two words, so LSL 2.
+  __ sll(TMP1, T3, 2);
+  __ addu(TMP1, T2, TMP1);
+  __ lw(T4, FieldAddress(TMP, base));
+
+  ASSERT(kIllegalCid == 0);
+  __ beq(T4, ZR, &call_target_function);
+  __ bne(T4, T0, &update);
+
+  __ Bind(&call_target_function);
+  // Call the target found in the cache.  For a class id match, this is a
+  // proper target for the given name and arguments descriptor.  If the
+  // illegal class id was found, the target is a cache miss handler that can
+  // be invoked as a normal Dart function.
+  __ sll(TMP1, T3, 2);
+  __ addu(TMP1, T2, TMP1);
+  __ lw(T0, FieldAddress(TMP, base + kWordSize));
+  __ lw(T0, FieldAddress(T0, Function::code_offset()));
+  __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
+  __ LoadObject(S5, ic_data);
+  __ LoadObject(S4, arguments_descriptor);
+  __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
+  __ jalr(T0);
+  AddCurrentDescriptor(PcDescriptors::kOther, Isolate::kNoDeoptId, token_pos);
+  RecordSafepoint(locs);
+  AddDeoptIndexAtCall(Isolate::ToDeoptAfter(deopt_id), token_pos);
+  __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitStaticCall(const Function& function,
                                        const Array& arguments_descriptor,
                                        intptr_t argument_count,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        LocationSummary* locs) {
   __ TraceSimMsg("StaticCall");
   __ LoadObject(S4, arguments_descriptor);
   // Do not use the code from the function, but let the code be patched so that
   // we can record the outgoing edges to other code.
   GenerateDartCall(deopt_id,
                    token_pos,
                    &StubCode::CallStaticFunctionLabel(),
                    PcDescriptors::kFuncCall,
                    locs);
   AddStaticCallTarget(function);
   __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegConstCompare(Register reg,
                                                     const Object& obj,
                                                     bool needs_number_check,
                                                     intptr_t token_pos) {
+  __ TraceSimMsg("EqualityRegConstCompare");
   if (needs_number_check &&
       (obj.IsMint() || obj.IsDouble() || obj.IsBigint())) {
     __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(reg, Address(SP, 1 * kWordSize));
     __ LoadObject(TMP1, obj);
     __ BranchLink(&StubCode::IdenticalWithNumberCheckLabel());
     AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                          Isolate::kNoDeoptId,
                          token_pos);
     __ delay_slot()->sw(TMP1, Address(SP, 0 * kWordSize));
+    __ TraceSimMsg("EqualityRegConstCompare return");
     __ lw(reg, Address(SP, 1 * kWordSize));  // Restore 'reg'.
     __ addiu(SP, SP, Immediate(2 * kWordSize));  // Discard constant.
     return;
   }
   __ CompareObject(CMPRES, TMP1, reg, obj);
 }
 
 
 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
                                                   Register right,
@@ skipping 13 matching lines @@
     __ lw(right, Address(SP, 0 * kWordSize));
     __ lw(left, Address(SP, 1 * kWordSize));
     __ addiu(SP, SP, Immediate(2 * kWordSize));
   } else {
     __ slt(CMPRES, left, right);
     __ slt(TMP1, right, left);
   }
 }
 
 
+// Implement equality spec: if any of the arguments is null do identity check.
+// Fallthrough calls super equality.
 void FlowGraphCompiler::EmitSuperEqualityCallPrologue(Register result,
                                                       Label* skip_call) {
-  UNIMPLEMENTED();
+  Label check_identity, is_false, fall_through;
+  __ TraceSimMsg("SuperEqualityCallPrologue");
+  __ lw(result, Address(SP, 0 * kWordSize));  // Load right operand.
+  __ lw(TMP1, Address(SP, 1 * kWordSize));  // Load left operand.
+  __ beq(result, NULLREG, &check_identity);  // Is right null?
+  __ bne(TMP1, NULLREG, &fall_through);  // If right is non-null, check left.
+
+  __ Bind(&check_identity);
+  __ bne(result, TMP1, &is_false);
+  __ LoadObject(result, Bool::True());
+  __ Drop(2);
+  __ b(skip_call);
+  __ Bind(&is_false);
+  __ LoadObject(result, Bool::False());
+  __ Drop(2);
+  __ b(skip_call);
+  __ Bind(&fall_through);
 }
 
 
 void FlowGraphCompiler::SaveLiveRegisters(LocationSummary* locs) {
   __ TraceSimMsg("SaveLiveRegisters");
   // TODO(vegorov): consider saving only caller save (volatile) registers.
   const intptr_t fpu_registers = locs->live_registers()->fpu_registers();
   if (fpu_registers > 0) {
     UNIMPLEMENTED();
   }
@@ skipping 36 matching lines @@
 
   const intptr_t fpu_registers = locs->live_registers()->fpu_registers();
   if (fpu_registers > 0) {
     UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphCompiler::EmitTestAndCall(const ICData& ic_data,
                                         Register class_id_reg,
-                                        intptr_t arg_count,
-                                        const Array& arg_names,
+                                        intptr_t argument_count,
+                                        const Array& argument_names,
                                         Label* deopt,
                                         intptr_t deopt_id,
                                         intptr_t token_index,
                                         LocationSummary* locs) {
-  UNIMPLEMENTED();
+  ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
+  Label match_found;
+  const intptr_t len = ic_data.NumberOfChecks();
+  GrowableArray<CidTarget> sorted(len);
+  SortICDataByCount(ic_data, &sorted);
+  ASSERT(class_id_reg != S4);
+  ASSERT(len > 0);  // Why bother otherwise.
+  const Array& arguments_descriptor =
+      Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
+                                                 argument_names));
+  __ TraceSimMsg("EmitTestAndCall");
+  __ LoadObject(S4, arguments_descriptor);
+  for (intptr_t i = 0; i < len; i++) {
+    const bool is_last_check = (i == (len - 1));
+    Label next_test;
+    if (is_last_check) {
+      __ BranchNotEqual(class_id_reg, sorted[i].cid, deopt);
+    } else {
+      __ BranchNotEqual(class_id_reg, sorted[i].cid, &next_test);
+    }
+    // Do not use the code from the function, but let the code be patched so
+    // that we can record the outgoing edges to other code.
+    GenerateDartCall(deopt_id,
+                     token_index,
+                     &StubCode::CallStaticFunctionLabel(),
+                     PcDescriptors::kFuncCall,
+                     locs);
+    const Function& function = *sorted[i].target;
+    AddStaticCallTarget(function);
+    __ Drop(argument_count);
+    if (!is_last_check) {
+      __ b(&match_found);
+    }
+    __ Bind(&next_test);
+  }
+  __ Bind(&match_found);
 }
 
 
 void FlowGraphCompiler::EmitDoubleCompareBranch(Condition true_condition,
                                                 FpuRegister left,
                                                 FpuRegister right,
                                                 BranchInstr* branch) {
   UNIMPLEMENTED();
 }
 
@@ skipping 237 matching lines @@
   __ AddImmediate(SP, kDoubleSize);
 }
 
 
 #undef __
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS