Split BinaryOp into BinarySmiOp and BinaryMintOp.

runtime/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 1409 matching lines @@
 
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
   __ movq(temp, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(temp, 0));
   __ j(BELOW_EQUAL, slow_path->entry_label());
   __ Bind(slow_path->exit_label());
 }
 
 
-LocationSummary* BinaryOpComp::MakeLocationSummary() const {
+LocationSummary* BinarySmiOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-
-  // 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;
-  }
-
-  ASSERT(operands_type() == kSmiOperands);
-
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 3;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RegisterLocation(RBX));
     // Will be used for for sign extension.
     summary->set_temp(1, Location::RegisterLocation(RDX));
@@ skipping 25 matching lines @@
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
 }
 
 
-static void EmitSmiBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
-  Register left = comp->locs()->in(0).reg();
-  Register right = comp->locs()->in(1).reg();
-  Register result = comp->locs()->out().reg();
-  Register temp = comp->locs()->temp(0).reg();
+void BinarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  Register result = locs()->out().reg();
+  Register temp = locs()->temp(0).reg();
   ASSERT(left == result);
-  const bool left_is_smi = comp->left()->ResultCid() == kSmiCid;
-  const bool right_is_smi = comp->right()->ResultCid() == kSmiCid;
+  const bool left_is_smi = this->left()->ResultCid() == kSmiCid;
+  const bool right_is_smi = this->right()->ResultCid() == kSmiCid;
   bool can_deopt;
-  switch (comp->op_kind()) {
+  switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       can_deopt = !(right_is_smi && left_is_smi);
       break;
     default:
       can_deopt = true;
   }
   Label* deopt = NULL;
   if (can_deopt) {
-    deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
-                                   comp->instance_call()->try_index(),
-                                   kDeoptSmiBinaryOp);
+    deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
+                                   instance_call()->try_index(),
+                                   kDeoptBinarySmiOp);
   }
   if (!left_is_smi || !right_is_smi) {
     __ movq(temp, left);
     __ orq(temp, right);
     __ testq(temp, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
   }
-  switch (comp->op_kind()) {
+  switch (op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kSUB: {
       __ subq(left, right);
       __ j(OVERFLOW, deopt);
       break;
     }
@@ skipping 19 matching lines @@
       break;
     }
     case Token::kTRUNCDIV: {
       // Handle divide by zero in runtime.
       // Deoptimization requires that temp and right are preserved.
       __ testq(right, right);
       __ j(ZERO, deopt);
       ASSERT(left == RAX);
       ASSERT((right != RDX) && (right != RAX));
       ASSERT((temp != RDX) && (temp != RAX));
-      ASSERT(comp->locs()->temp(1).reg() == RDX);
+      ASSERT(locs()->temp(1).reg() == RDX);
       ASSERT(result == RAX);
-      Register right_temp = comp->locs()->temp(2).reg();
+      Register right_temp = locs()->temp(2).reg();
       __ movq(right_temp, right);
       __ SmiUntag(left);
       __ SmiUntag(right_temp);
       __ cqo();  // Sign extend RAX -> RDX:RAX.
       __ idivq(right_temp);  //  RAX: quotient, RDX: remainder.
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ cmpq(result, Immediate(0x4000000000000000));
       __ j(EQUAL, deopt);
       __ SmiTag(result);
@@ skipping 16 matching lines @@
       __ SmiTag(left);
       break;
     }
     case Token::kSHL: {
       Label call_method, done;
       // Check if count too large for handling it inlined.
       __ movq(temp, left);
       __ cmpq(right,
           Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
       __ j(ABOVE_EQUAL, &call_method, Assembler::kNearJump);
-      Register right_temp = comp->locs()->temp(1).reg();
+      Register right_temp = locs()->temp(1).reg();
       ASSERT(right_temp == RCX);  // Count must be in RCX
       __ movq(right_temp, right);
       __ SmiUntag(right_temp);
       // Overflow test (preserve temp and right);
       __ shlq(left, right_temp);
       __ sarq(left, right_temp);
       __ cmpq(left, temp);
       __ j(NOT_EQUAL, &call_method, Assembler::kNearJump);  // Overflow.
       // Shift for result now we know there is no overflow.
       __ shlq(left, right_temp);
       __ jmp(&done);
       {
         __ Bind(&call_method);
         Function& target = Function::ZoneHandle(
-            comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
+            ic_data()->GetTargetForReceiverClassId(kSmiCid));
         ASSERT(!target.IsNull());
         const intptr_t kArgumentCount = 2;
         __ pushq(temp);
         __ pushq(right);
         compiler->GenerateStaticCall(
-            comp->instance_call()->deopt_id(),
-            comp->instance_call()->token_pos(),
-            comp->instance_call()->try_index(),
+            instance_call()->deopt_id(),
+            instance_call()->token_pos(),
+            instance_call()->try_index(),
             target,
             kArgumentCount,
             Array::Handle(),  // No argument names.
-            comp->locs()->stack_bitmap());
+            locs()->stack_bitmap());
         ASSERT(result == RAX);
       }
       __ Bind(&done);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
@@ skipping 10 matching lines @@
       UNREACHABLE();
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
-static void EmitMintBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
+LocationSummary* BinaryMintOpComp::MakeLocationSummary() const {
+  ASSERT(op_kind() == Token::kBIT_AND);
+  const intptr_t kNumInputs = 2;
+  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;
+}
+
+
+void BinaryMintOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // TODO(regis): For now, we only support Token::kBIT_AND for a Mint or Smi
   // receiver and a Mint or Smi argument. We fall back to the run time call if
   // both receiver and argument are Mint or if one of them is Mint and the other
   // is a negative Smi.
-  Register left = comp->locs()->in(0).reg();
-  Register right = comp->locs()->in(1).reg();
-  Register result = comp->locs()->out().reg();
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  Register result = locs()->out().reg();
   ASSERT(left == result);
-  ASSERT(comp->op_kind() == Token::kBIT_AND);
-  Label* deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
-                                        comp->instance_call()->try_index(),
-                                        kDeoptMintBinaryOp);
+  ASSERT(op_kind() == Token::kBIT_AND);
+  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
+                                        instance_call()->try_index(),
+                                        kDeoptBinaryMintOp);
   Label mint_static_call, smi_static_call, non_smi, smi_smi, done;
   __ testq(left, Immediate(kSmiTagMask));  // Is receiver Smi?
   __ j(NOT_ZERO, &non_smi);
   __ testq(right, Immediate(kSmiTagMask));  // Is argument Smi?
   __ j(ZERO, &smi_smi);
   __ CompareClassId(right, kMintCid);  // Is argument Mint?
   __ j(NOT_EQUAL, deopt);  // Argument neither Smi nor Mint.
   __ cmpq(left, Immediate(0));
   __ j(LESS, &smi_static_call);  // Negative Smi receiver, Mint argument.
 
@@ skipping 16 matching lines @@
   // Load lower receiver Mint word, convert to Smi. It is OK to loose bits.
   __ movq(result, FieldAddress(left, Mint::value_offset()));
   __ SmiTag(result);
   __ Bind(&smi_smi);
   __ andq(result, right);
   __ jmp(&done);
 
   __ Bind(&smi_static_call);
   {
     Function& target = Function::ZoneHandle(
-        comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
+        ic_data()->GetTargetForReceiverClassId(kSmiCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
       compiler->GenerateStaticCall(
-          comp->instance_call()->deopt_id(),
-          comp->instance_call()->token_pos(),
-          comp->instance_call()->try_index(),
+          instance_call()->deopt_id(),
+          instance_call()->token_pos(),
+          instance_call()->try_index(),
           target,
-          comp->instance_call()->ArgumentCount(),
-          comp->instance_call()->argument_names(),
-          comp->locs()->stack_bitmap());
+          instance_call()->ArgumentCount(),
+          instance_call()->argument_names(),
+          locs()->stack_bitmap());
       ASSERT(result == RAX);
       __ jmp(&done);
     }
   }
 
   __ Bind(&mint_static_call);
   {
     Function& target = Function::ZoneHandle(
-        comp->ic_data()->GetTargetForReceiverClassId(kMintCid));
+        ic_data()->GetTargetForReceiverClassId(kMintCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
       compiler->GenerateStaticCall(
-          comp->instance_call()->deopt_id(),
-          comp->instance_call()->token_pos(),
-          comp->instance_call()->try_index(),
+          instance_call()->deopt_id(),
+          instance_call()->token_pos(),
+          instance_call()->try_index(),
           target,
-          comp->instance_call()->ArgumentCount(),
-          comp->instance_call()->argument_names(),
-          comp->locs()->stack_bitmap());
+          instance_call()->ArgumentCount(),
+          instance_call()->argument_names(),
+          locs()->stack_bitmap());
       ASSERT(result == RAX);
     }
   }
   __ Bind(&done);
 }
 
 
-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 {
+LocationSummary* BinaryDoubleOpComp::MakeLocationSummary() const {
   return MakeCallSummary();  // Calls into a stub for allocation.
 }
 
 
-void DoubleBinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinaryDoubleOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = RBX;
   Register right = RCX;
   Register temp = RDX;
   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(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther,
                          locs()->stack_bitmap());
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == RAX);
   __ movq(right, Address(RSP, 0));
   __ movq(left, Address(RSP, kWordSize));
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
-                                        kDeoptDoubleBinaryOp);
+                                        kDeoptBinaryDoubleOp);
 
   // Binary operation of two Smi's produces a Smi not a double.
   __ movq(temp, left);
   __ orq(temp, right);
   __ testq(temp, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
 
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
@@ skipping 416 matching lines @@
     }
   }
   __ Bind(&is_ok);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64