Fix equality code on ARM.

runtime/vm/intermediate_language_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 338 matching lines @@
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(R1));
   locs->set_in(1, Location::RegisterLocation(R0));
   locs->set_temp(0, Location::RegisterLocation(R5));
   locs->set_out(Location::RegisterLocation(R0));
   return locs;
 }
 
 
-// R1: left.
-// R0: right.
-// Uses R5 to load ic_call_data.
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        Token::Kind kind,
                                        LocationSummary* locs,
                                        const ICData& original_ic_data) {
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id,
                                    token_pos);
   }
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
   Label check_identity;
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
+  __ ldm(IA, SP, (1 << R0) | (1 << R1));
   __ cmp(R1, ShifterOperand(IP));
   __ b(&check_identity, EQ);
   __ cmp(R0, ShifterOperand(IP));
   __ b(&check_identity, EQ);
 
   ICData& equality_ic_data = ICData::ZoneHandle();
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
     if (original_ic_data.NumberOfChecks() == 0) {
       // IC call for reoptimization populates original ICData.
       equality_ic_data = original_ic_data.raw();
     } else {
       // Megamorphic call.
       equality_ic_data = original_ic_data.AsUnaryClassChecks();
     }
   } else {
     equality_ic_data = ICData::New(compiler->parsed_function().function(),
                                    Symbols::EqualOperator(),
                                    deopt_id,
                                    kNumArgumentsChecked);
   }
-  __ PushList((1 << R0) | (1 << R1));
   compiler->GenerateInstanceCall(deopt_id,
                                  token_pos,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  locs,
                                  equality_ic_data);
   Label check_ne;
   __ b(&check_ne);
 
   __ Bind(&check_identity);
   Label equality_done;
   if (compiler->is_optimizing()) {
     // No need to update IC data.
+    __ PopList((1 << R0) | (1 << R1));
     __ cmp(R0, ShifterOperand(R1));
     __ LoadObject(R0, (kind == Token::kEQ) ? Bool::False() : Bool::True(), NE);
     __ LoadObject(R0, (kind == Token::kEQ) ? Bool::True() : Bool::False(), EQ);
     if (kind == Token::kNE) {
       // Skip not-equal result conversion.
       __ b(&equality_done);
     }
   } else {
     // Call stub, load IC data in register. The stub will update ICData if
     // necessary.
     Register ic_data_reg = locs->temp(0).reg();
     ASSERT(ic_data_reg == R5);  // Stub depends on it.
     __ LoadObject(ic_data_reg, equality_ic_data);
     // Pass left in R1 and right in R0.
     compiler->GenerateCall(token_pos,
                            &StubCode::EqualityWithNullArgLabel(),
                            PcDescriptors::kRuntimeCall,
                            locs);
+    __ Drop(2);
   }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     // Negate the condition: true label returns false and vice versa.
     __ CompareObject(R0, Bool::True());
     __ LoadObject(R0, Bool::True(), NE);
     __ LoadObject(R0, Bool::False(), EQ);
   }
   __ Bind(&equality_done);
 }
@@ skipping 30 matching lines @@
     case LS: return HI;
     case HI: return LS;
     case CS: return CC;
     default:
       UNIMPLEMENTED();
       return EQ;
   }
 }
 
 
-// R1: left.
-// R0: right.
+// R1: left, also on stack.
+// R0: right, also on stack.
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           LocationSummary* locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   ASSERT(ic_data.NumberOfChecks() > 0);
@@ skipping 17 matching lines @@
     Label next_test;
     __ CompareImmediate(temp, ic_data.GetReceiverClassIdAt(i));
     if (i < len - 1) {
       __ b(&next_test, NE);
     } else {
       __ b(deopt, NE);
     }
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     if (target.Owner() == object_store->object_class()) {
       // Object.== is same as ===.
+      __ Drop(2);
       __ cmp(left, ShifterOperand(right));
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         Register result = locs->out().reg();
         __ LoadObject(result, Bool::True(), cond);
         __ LoadObject(result, Bool::False(), NegateCondition(cond));
       }
     } else {
-      __ PushList((1 << R0) | (1 << R1));
       const int kNumberOfArguments = 2;
       const Array& kNoArgumentNames = Array::Handle();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames,
                                    locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
@@ skipping 61 matching lines @@
     __ b(&load_true, cond);
     __ LoadObject(result, Bool::False());
     __ b(&done);
     __ Bind(&load_true);
     __ LoadObject(result, Bool::True());
   }
   __ b(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   ASSERT(left == R1);
   ASSERT(right == R0);
+  __ PushList((1 << R0) | (1 << R1));
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 deopt_id, token_pos);
   __ Bind(&done);
 }
 
 
 static Condition FlipCondition(Condition condition) {
   switch (condition) {
     case EQ: return EQ;
     case NE: return NE;
@@ skipping 89 matching lines @@
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), kNoBranch, *ic_data(),
                                deopt_id(), token_pos());
     return;
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   ASSERT(left == R1);
   ASSERT(right == R0);
+  __ PushList((1 << R0) | (1 << R1));
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              kind(),
                              locs(),
                              *ic_data());
   ASSERT(locs()->out().reg() == R0);
 }
 
 
@@ skipping 22 matching lines @@
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), branch, *ic_data(),
                                deopt_id(), token_pos());
     return;
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   ASSERT(left == R1);
   ASSERT(right == R0);
+  __ PushList((1 << R0) | (1 << R1));
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(R0, token_pos(), deopt_id(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
@@ skipping 2248 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM