Merge TRUNCDIV and MOD into TRUNCDIV_MOD single operation.

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 2169 matching lines @@
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
   ConstantInstr* right_constant = right()->definition()->AsConstant();
   if ((right_constant != NULL) &&
       (op_kind() != Token::kTRUNCDIV) &&
       (op_kind() != Token::kSHL) &&
       (op_kind() != Token::kMUL) &&
       (op_kind() != Token::kMOD) &&
+      (op_kind() != Token::kTRUNCDIVMOD) &&
       CanBeImmediate(right_constant->value())) {
     const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::Constant(right_constant->value()));
     summary->set_out(Location::SameAsFirstInput());
     return summary;
   }
 
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     if (RightIsPowerOfTwoConstant()) {
       summary->set_in(0, Location::RequiresRegister());
       ConstantInstr* right_constant = right()->definition()->AsConstant();
       summary->set_in(1, Location::Constant(right_constant->value()));
       summary->set_temp(0, Location::RequiresRegister());
       summary->set_out(Location::SameAsFirstInput());
     } else {
       // Both inputs must be writable because they will be untagged.
       summary->set_in(0, Location::RegisterLocation(RAX));
       summary->set_in(1, Location::WritableRegister());
       summary->set_out(Location::SameAsFirstInput());
       // Will be used for sign extension and division.
       summary->set_temp(0, Location::RegisterLocation(RDX));
     }
     return summary;
+  } else if (op_kind() == Token::kTRUNCDIVMOD) {
+    const intptr_t kNumTemps = 1;
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    // Both inputs must be writable because they will be untagged.
+    summary->set_in(0, Location::RegisterLocation(RAX));
+    summary->set_in(1, Location::WritableRegister());
+    summary->set_out(Location::RequiresRegister());
+    // Will be used for sign extension and division.
+    summary->set_temp(0, Location::RegisterLocation(RDX));
+    return summary;
   } else if (op_kind() == Token::kMOD) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     // Both inputs must be writable because they will be untagged.
     summary->set_in(0, Location::RegisterLocation(RDX));
     summary->set_in(1, Location::WritableRegister());
     summary->set_out(Location::SameAsFirstInput());
     // Will be used for sign extension and division.
     summary->set_temp(0, Location::RegisterLocation(RAX));
@@ skipping 35 matching lines @@
 
 void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (op_kind() == Token::kSHL) {
     EmitSmiShiftLeft(compiler, this);
     return;
   }
 
   ASSERT(!is_truncating());
   Register left = locs()->in(0).reg();
   Register result = locs()->out().reg();
-  ASSERT(left == result);
+  // DIVMOD is different.
+  ASSERT((op_kind() == Token::kTRUNCDIVMOD) || (left == result));
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt = compiler->AddDeoptStub(deopt_id(),
                                    kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int64_t imm =
@@ skipping 280 matching lines @@
       __ cmpq(right, Immediate(0));
       __ j(LESS, &subtract, Assembler::kNearJump);
       __ addq(result, right);
       __ jmp(&all_done, Assembler::kNearJump);
       __ Bind(&subtract);
       __ subq(result, right);
       __ Bind(&all_done);
       __ SmiTag(result);
       break;
     }
+    case Token::kTRUNCDIVMOD: {

[Florian Schneider, 2013/11/14 10:17:44]

I'm not sure how much making this operation a BinarySmiOp is buying: It is very
different from all other smi-ops: There are many places where this instructions
needs to be treated specially.

I guess it would have saved you from changing all the function fingerprints due
to introducing a new token.

[srdjan, 2013/11/20 21:41:47]

Created new instructions as suggested.

+      Label not_32bit, done;
+      Register temp = locs()->temp(0).reg();
+      ASSERT(left == RAX);
+      ASSERT((right != RDX) && (right != RAX));
+      ASSERT(temp == RDX);
+      ASSERT((result != RDX) && (result != RAX));
+      // Handle divide by zero in runtime.
+      __ testq(right, right);
+      __ j(ZERO, deopt);
+      // Check if both operands fit into 32bits as idiv with 64bit operands
+      // requires twice as many cycles and has much higher latency.
+      // We are checking this before untagging them to avoid corner case
+      // dividing INT_MAX by -1 that raises exception because quotient is
+      // too large for 32bit register.
+      __ movsxd(temp, left);
+      __ cmpq(temp, left);
+      __ j(NOT_EQUAL, &not_32bit);
+      __ movsxd(temp, right);
+      __ cmpq(temp, right);
+      __ j(NOT_EQUAL, &not_32bit);
+
+      // Both operands are 31bit smis. Divide using 32bit idiv.
+      __ SmiUntag(left);
+      __ SmiUntag(right);
+      __ cdq();
+      __ idivl(right);
+      __ movsxd(RAX, RAX);
+      __ movsxd(RDX, RDX);
+      __ jmp(&done);
+
+      // Divide using 64bit idiv.
+      __ Bind(&not_32bit);
+      __ SmiUntag(left);
+      __ SmiUntag(right);
+      __ cqo();  // Sign extend RAX -> RDX:RAX.
+      __ idivq(right);  //  RAX: quotient, RDX: remainder.
+      // Check the corner case of dividing the 'MIN_SMI' with -1, in which
+      // case we cannot tag the result.
+      __ CompareImmediate(RAX, Immediate(0x4000000000000000), PP);
+      __ j(EQUAL, deopt);
+      __ Bind(&done);
+
+      // Modulo correction (RDX).
+      //  res = left % right;
+      //  if (res < 0) {
+      //    if (right < 0) {
+      //      res = res - right;
+      //    } else {
+      //      res = res + right;
+      //    }
+      //  }
+      Label subtract, all_done;
+      __ cmpq(RDX, Immediate(0));
+      __ j(GREATER_EQUAL, &all_done, Assembler::kNearJump);
+      // Result is negative, adjust it.
+      __ cmpq(right, Immediate(0));
+      __ j(LESS, &subtract, Assembler::kNearJump);
+      __ addq(RDX, right);
+      __ jmp(&all_done, Assembler::kNearJump);
+      __ Bind(&subtract);
+      __ subq(RDX, right);
+      __ Bind(&all_done);
+      __ SmiTag(result);
+
+      __ LoadObject(result, Array::ZoneHandle(Array::New(2, Heap::kOld)), PP);
+      const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(kArrayCid);
+      Address trunc_div_address(
+          FlowGraphCompiler::ElementAddressForIntIndex(kArrayCid,
+                                                       index_scale,
+                                                       result,
+                                                       0));
+      Address mod_address(
+          FlowGraphCompiler::ElementAddressForIntIndex(kArrayCid,
+                                                       index_scale,
+                                                       result,
+                                                       1));
+      __ SmiTag(RAX);
+      __ SmiTag(RDX);
+      __ StoreIntoObjectNoBarrier(result, trunc_div_address, RAX);
+      __ StoreIntoObjectNoBarrier(result, mod_address, RDX);
+      break;
+    }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareImmediate(right, Immediate(0), PP);
         __ j(LESS, deopt);
       }
       __ SmiUntag(right);
       // sarq operation masks the count to 6 bits.
       const intptr_t kCountLimit = 0x3F;
       Range* right_range = this->right()->definition()->range();
       if ((right_range == NULL) ||
@@ skipping 21 matching lines @@
       // Flow graph builder has dissected this operation to guarantee correct
       // behavior (short-circuit evaluation).
       UNREACHABLE();
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptOverflowCheck(compiler, range(), deopt, result);

[Florian Schneider, 2013/11/14 10:17:44]

DIVMOD won't work with --throw_on_javascript_int_overflow here.

[srdjan, 2013/11/20 21:41:47]

Good point, fixing it.

   }
 }
 
 
 LocationSummary* CheckEitherNonSmiInstr::MakeLocationSummary() const {
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   ASSERT((left_cid != kDoubleCid) && (right_cid != kDoubleCid));
   const intptr_t kNumInputs = 2;
   const bool need_temp = (left_cid != kSmiCid) && (right_cid != kSmiCid);
@@ skipping 1990 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64