Implements missing features to run Hello, World in checked mode on MIPS.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 1644 matching lines @@
   ASSERT(kExceptionObjectReg == V0);
   ASSERT(kStackTraceObjectReg == V1);
   __ mov(V0, A3);  // Exception object.
   __ lw(V1, Address(SP, 0));  // StackTrace object.
   __ mov(FP, A2);  // Frame_pointer.
   __ mov(SP, A1);  // Stack pointer.
   __ jr(A0);  // Jump to the exception handler code.
 }
 
 
+// Implements equality operator when one of the arguments is null
+// (identity check) and updates ICData if necessary.
+// RA: return address.
+// A1: left argument.
+// A0: right argument.
+// T0: ICData.
+// V0: result.
+// TODO(srdjan): Move to VM stubs once Boolean objects become VM objects.
 void StubCode::GenerateEqualityWithNullArgStub(Assembler* assembler) {
-  __ Unimplemented("EqualityWithNullArg Stub");
+  __ EnterStubFrame();
+  static const intptr_t kNumArgsTested = 2;
+#if defined(DEBUG)
+  { Label ok;
+    __ lw(TMP1, FieldAddress(T0, ICData::num_args_tested_offset()));
+    __ BranchEqual(TMP1, kNumArgsTested, &ok);
+    __ Stop("Incorrect ICData for equality");
+    __ Bind(&ok);
+  }
+#endif  // DEBUG
+  // Check IC data, update if needed.
+  // T0: IC data object (preserved).
+  __ lw(T6, FieldAddress(T0, ICData::ic_data_offset()));
+  // T6: ic_data_array with check entries: classes and target functions.
+  __ AddImmediate(T6, Array::data_offset() - kHeapObjectTag);
+  // T6: points directly to the first ic data array element.
+
+  Label get_class_id_as_smi, no_match, loop, found;
+  __ Bind(&loop);
+  // Check left.
+  __ bal(&get_class_id_as_smi);
+  __ delay_slot()->mov(T2, A1);
+  __ lw(T3, Address(T6, 0 * kWordSize));
+  __ bne(T2, T3, &no_match);  // Class id match?
+
+  // Check right.
+  __ bal(&get_class_id_as_smi);
+  __ delay_slot()->mov(T2, A0);
+  __ lw(T3, Address(T6, 1 * kWordSize));
+  __ beq(T2, T3, &found);  // Class id match?
+  __ Bind(&no_match);
+  // Next check group.
+  __ AddImmediate(T6, kWordSize * ICData::TestEntryLengthFor(kNumArgsTested));
+  __ BranchNotEqual(T3, Smi::RawValue(kIllegalCid), &loop);  // Done?
+
+  Label update_ic_data;
+  __ b(&update_ic_data);
+
+  __ Bind(&found);
+  const intptr_t count_offset =
+      ICData::CountIndexFor(kNumArgsTested) * kWordSize;
+  Label no_overflow;
+  __ lw(T1, Address(T6, count_offset));
+  __ AddImmediateDetectOverflow(T1, T1, Smi::RawValue(1), CMPRES);
+  __ bgez(CMPRES, &no_overflow);
+  __ LoadImmediate(TMP1, Smi::RawValue(Smi::kMaxValue));
+  __ sw(TMP1, Address(T6, count_offset));  // If overflow.
+  __ Bind(&no_overflow);
+
+  Label compute_result;
+  __ Bind(&compute_result);
+  __ LoadObject(TMP1, Bool::True());
+  __ LoadObject(TMP2, Bool::False());
+  __ subu(CMPRES, A0, A1);
+  __ movz(V0, TMP1, CMPRES);
+  __ movn(V0, TMP2, CMPRES);
+  __ LeaveStubFrame();
+  __ Ret();
+
+  __ Bind(&get_class_id_as_smi);
+  // Test if Smi -> load Smi class for comparison.
+  Label not_smi;
+  __ andi(CMPRES, T2, Immediate(kSmiTagMask));
+  __ bne(CMPRES, ZR, &not_smi);
+  __ jr(RA);
+  __ delay_slot()->addiu(T2, ZR, Immediate(Smi::RawValue(kSmiCid)));
+  __ Bind(&not_smi);
+  __ LoadClassId(T2, T2);
+  __ jr(RA);
+  __ delay_slot()->SmiTag(T2);
+
+  __ Bind(&update_ic_data);
+  // T0: ICData
+  __ addiu(SP, SP, Immediate(-4 * kWordSize));
+  __ sw(A1, Address(SP, 3 * kWordSize));
+  __ sw(A0, Address(SP, 2 * kWordSize));
+  __ LoadObject(TMP1, Symbols::EqualOperator());  // Target's name.
+  __ sw(TMP1, Address(SP, 1 * kWordSize));
+  __ sw(T0, Address(SP, 0 * kWordSize));  // ICData.
+  __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry);
+  __ lw(A0, Address(SP, 2 * kWordSize));
+  __ lw(A1, Address(SP, 3 * kWordSize));
+  __ b(&compute_result);
+  __ delay_slot()->addiu(SP, SP, Immediate(4 * kWordSize));
 }
 
 
 // Calls to the runtime to optimize the given function.
 // T0: function to be reoptimized.
 // S4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ TraceSimMsg("OptimizeFunctionStub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
@@ skipping 113 matching lines @@
   __ Bind(&done);
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(T1, Address(SP, 1 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS