Separate double binary operation into a separate instruction class.

vm/intermediate_language_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 1497 matching lines @@
                                 token_pos(),
                                 try_index(),
                                 kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
-  if (operands_type() == kDoubleOperands) {
-    return MakeCallSummary();  // Calls into a stub for allocation.
-  }
+  // Double operation are handled in DoubleBinaryOpComp.
+  ASSERT(operands_type() != kDoubleOperands);
 
   if (operands_type() == kMintOperands) {
     ASSERT(op_kind() == Token::kBIT_AND);
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::RegisterLocation(RAX));
     return summary;
@@ skipping 283 matching lines @@
                                    target,
                                    comp->instance_call()->ArgumentCount(),
                                    comp->instance_call()->argument_names());
       ASSERT(result == RAX);
     }
   }
   __ Bind(&done);
 }
 
 
-static void EmitDoubleBinaryOp(FlowGraphCompiler* compiler,
-                               BinaryOpComp* comp) {
+void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  switch (operands_type()) {
+    case kSmiOperands:
+      EmitSmiBinaryOp(compiler, this);
+      break;
+
+    case kMintOperands:
+      EmitMintBinaryOp(compiler, this);
+      break;
+
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+LocationSummary* DoubleBinaryOpComp::MakeLocationSummary() const {
+  return MakeCallSummary();  // Calls into a stub for allocation.
+}
+
+
+void DoubleBinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = RBX;
   Register right = RCX;
   Register temp = RDX;
-  Register result = comp->locs()->out().reg();
+  Register result = locs()->out().reg();
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
-  compiler->GenerateCall(comp->instance_call()->token_pos(),
-                         comp->instance_call()->try_index(),
+  compiler->GenerateCall(instance_call()->token_pos(),
+                         instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther);
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == RAX);
   __ popq(right);
   __ popq(left);
 
-  Label* deopt = compiler->AddDeoptStub(comp->instance_call()->cid(),
-                                        comp->instance_call()->token_pos(),
-                                        comp->instance_call()->try_index(),
+  Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
+                                        instance_call()->token_pos(),
+                                        instance_call()->try_index(),
                                         kDeoptDoubleBinaryOp,
                                         left,
                                         right);
 
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
-  switch (comp->op_kind()) {
+  switch (op_kind()) {
     case Token::kADD: __ addsd(XMM0, XMM1); break;
     case Token::kSUB: __ subsd(XMM0, XMM1); break;
     case Token::kMUL: __ mulsd(XMM0, XMM1); break;
     case Token::kDIV: __ divsd(XMM0, XMM1); break;
     default: UNREACHABLE();
   }
 
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 }
 
 
-void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  switch (operands_type()) {
-    case kSmiOperands:
-      EmitSmiBinaryOp(compiler, this);
-      break;
-
-    case kMintOperands:
-      EmitMintBinaryOp(compiler, this);
-      break;
-
-    case kDoubleOperands:
-      EmitDoubleBinaryOp(compiler, this);
-      break;
-
-    default:
-      UNREACHABLE();
-  }
-}
-
-
 LocationSummary* UnarySmiOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
@@ skipping 308 matching lines @@
   ASSERT(locs()->out().reg() == RAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64