Allow equality operation on mixed double/smi arguments.

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 265 matching lines @@
     case Token::kGTE: return GE;
     default:
       UNREACHABLE();
       return VS;
   }
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (receiver_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
-  if (receiver_class_id() == kDoubleCid) {
+  if (operation_cid() == kDoubleCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
-  if (receiver_class_id() == kSmiCid) {
+  if (operation_cid() == kSmiCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RegisterOrConstant(left()));
     // Only one input can be a constant operand. The case of two constant
     // operands should be handled by constant propagation.
     locs->set_in(1, locs->in(0).IsConstant()
                         ? Location::RequiresRegister()
                         : Location::RegisterOrConstant(right()));
     locs->set_out(Location::RequiresRegister());
@@ skipping 423 matching lines @@
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, left, right, locs.out().reg());
   }
 }
 
 
 void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   BranchInstr* kNoBranch = NULL;
-  if (receiver_class_id() == kSmiCid) {
+  if (operation_cid() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch);
     return;
   }
-  if (receiver_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     EmitUnboxedMintEqualityOp(compiler, *locs(), kind(), kNoBranch);
     return;
   }
-  if (receiver_class_id() == kDoubleCid) {
+  if (operation_cid() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch);
     return;
   }
   if (IsCheckedStrictEqual()) {
     EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), kNoBranch,
                            deopt_id());
     return;
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), kNoBranch, *ic_data(),
@@ skipping 11 matching lines @@
                              kind(),
                              locs(),
                              *ic_data());
   ASSERT(locs()->out().reg() == R0);
 }
 
 
 void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                           BranchInstr* branch) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
-  if (receiver_class_id() == kSmiCid) {
+  if (operation_cid() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
-  if (receiver_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     EmitUnboxedMintEqualityOp(compiler, *locs(), kind(), branch);
     return;
   }
-  if (receiver_class_id() == kDoubleCid) {
+  if (operation_cid() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (IsCheckedStrictEqual()) {
     EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), branch,
                            deopt_id());
     return;
   }
   if (IsPolymorphic()) {
     EmitGenericEqualityCompare(compiler, locs(), kind(), branch, *ic_data(),
@@ skipping 16 matching lines @@
   }
   Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
   __ CompareObject(R0, Bool::True());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
-  if (operands_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     const intptr_t kNumTemps = 2;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresFpuRegister());
     locs->set_in(1, Location::RequiresFpuRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_temp(1, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
-  if (operands_class_id() == kDoubleCid) {
+  if (operation_cid() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresFpuRegister());
     summary->set_in(1, Location::RequiresFpuRegister());
     summary->set_out(Location::RequiresRegister());
     return summary;
-  } else if (operands_class_id() == kSmiCid) {
+  } else if (operation_cid() == kSmiCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RegisterOrConstant(left()));
     // Only one input can be a constant operand. The case of two constant
     // operands should be handled by constant propagation.
     summary->set_in(1, summary->in(0).IsConstant()
                            ? Location::RequiresRegister()
                            : Location::RegisterOrConstant(right()));
     summary->set_out(Location::RequiresRegister());
     return summary;
   }
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   // Pick arbitrary fixed input registers because this is a call.
   locs->set_in(0, Location::RegisterLocation(R0));
   locs->set_in(1, Location::RegisterLocation(R1));
   locs->set_out(Location::RegisterLocation(R0));
   return locs;
 }
 
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (operands_class_id() == kSmiCid) {
+  if (operation_cid() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
-  if (operands_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
-  if (operands_class_id() == kDoubleCid) {
+  if (operation_cid() == 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);
@@ skipping 48 matching lines @@
                                  token_pos(),
                                  kNumArguments,
                                  Object::null_array(),  // No optional args.
                                  locs(),
                                  relational_ic_data);
 }
 
 
 void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
-  if (operands_class_id() == kSmiCid) {
+  if (operation_cid() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
-  if (operands_class_id() == kMintCid) {
+  if (operation_cid() == kMintCid) {
     EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
-  if (operands_class_id() == kDoubleCid) {
+  if (operation_cid() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
   __ CompareObject(R0, Bool::True());
   branch->EmitBranchOnCondition(compiler, EQ);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary() const {
@@ skipping 3395 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM