Fix a bug in ia32 shift left , implemented more inlined binary operations in x64.

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 "lib/error.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 872 matching lines @@
   return NULL;
 }
 
 
 void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
-  const intptr_t kNumTemps = 1;
   const intptr_t kNumInputs = 2;
-  LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
-  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;
+  if (op_kind() == Token::kTRUNCDIV) {
+    const intptr_t kNumTemps = 3;
+    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    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));
+    summary->set_temp(2, Location::RequiresRegister());
+    return summary;
+  } else if (op_kind() == Token::kSHR) {
+    const intptr_t kNumTemps = 1;
+    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_in(1, Location::RegisterLocation(RCX));
+    summary->set_out(Location::SameAsFirstInput());
+    summary->set_temp(0, Location::RequiresRegister());
+    return summary;
+  } else if (op_kind() == Token::kSHL) {
+    const intptr_t kNumTemps = 2;
+    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_in(1, Location::RequiresRegister());
+    summary->set_out(Location::SameAsFirstInput());
+    summary->set_temp(0, Location::RequiresRegister());
+    summary->set_temp(1, Location::RegisterLocation(RCX));
+    return summary;
+  } else {
+    const intptr_t kNumTemps = 1;
+    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
+    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;
+  }
 }
 
 
 // TODO(srdjan): Implement variations.
 static bool TryEmitSmiBinaryOp(FlowGraphCompiler* compiler,
                                BinaryOpComp* comp) {
   ASSERT((comp->ic_data() != NULL));
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.IsNull()) return false;
   if (ic_data.num_args_tested() != 2) return false;
   if (ic_data.NumberOfChecks() != 1) return false;
   Function& target = Function::Handle();
   GrowableArray<const Class*> classes;
   ic_data.GetCheckAt(0, &classes, &target);
   const Class& smi_class =
       Class::Handle(Isolate::Current()->object_store()->smi_class());
   if ((classes[0]->raw() != smi_class.raw()) ||
       (classes[1]->raw() != smi_class.raw())) {
     return false;
   }
   // TODO(srdjan): need to allocate a temporary register (now using r10)
   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();
+  ASSERT(left == result);
   Label* deopt = compiler->AddDeoptStub(comp->instance_call()->cid(),
                                         comp->instance_call()->token_index(),
                                         comp->instance_call()->try_index(),
                                         kDeoptSmiBinaryOp,
                                         temp,
                                         right);
   __ movq(temp, left);
   __ orq(left, right);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
   __ movq(left, temp);
   switch (comp->op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       __ j(OVERFLOW, deopt);
-      if (result != left) {
-        __ movq(result, left);
-      }
       break;
     }
+    case Token::kSUB: {
+      __ subq(left, right);
+      __ j(OVERFLOW, deopt);
+      break;
+    }
+    case Token::kMUL: {
+      __ SmiUntag(left);
+      __ imulq(left, right);
+      __ j(OVERFLOW, deopt);
+      break;
+    }
+    case Token::kBIT_AND: {
+      // No overflow check.
+      __ andq(left, right);
+      break;
+    }
+    case Token::kBIT_OR: {

[Florian Schneider, 2012/05/30 14:21:12]

Maybe also add the same comment as in the BIT_AND and XOR case, or leave them
all out.

[srdjan, 2012/05/30 17:03:13]

Added it.

+      __ orq(left, right);
+      break;
+    }
+    case Token::kBIT_XOR: {
+      // No overflow check.
+      __ xorq(left, right);
+      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(result == RAX);
+      Register right_temp = comp->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);
+      break;
+    }
+    case Token::kDIV: {
+      // Dispatches to 'Double./'.
+      // TODO(srdjan): Implement as conversion to double and double division.
+      return false;
+    }
+    case Token::kMOD: {
+      // TODO(srdjan): Implement.
+      return false;
+    }
+    case Token::kSHR: {
+      const Immediate kCountLimit = Immediate(0x1F);
+      __ cmpq(right, Immediate(0));
+      __ j(LESS, deopt);
+      __ SmiUntag(right);
+      __ cmpq(right, kCountLimit);
+      Label count_ok;
+      __ j(LESS, &count_ok, Assembler::kNearJump);
+      __ movq(right, kCountLimit);
+      __ Bind(&count_ok);
+      ASSERT(right == RCX);  // Count must be in ECX
+      __ SmiUntag(left);
+      __ sarq(left, right);
+      __ SmiTag(left);
+      break;
+    }
+    case Token::kSHL: {
+      // Check if count too large for handling it inlined.
+      __ cmpq(right,
+          Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
+      __ j(ABOVE_EQUAL, deopt);
+      Register right_temp = comp->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, deopt);  // Overflow.
+      // Shift for result now we know there is no overflow.
+      __ shlq(left, right_temp);
+      break;
+    }
+    case Token::kOR:
+    case Token::kAND: {
+      // Flow graph builder has dissected this operation to guarantee correct
+      // behavior (short-circuit evaluation).
+      UNREACHABLE();
+    }
     default:
-      UNREACHABLE();
+      // Not implemented.
+      return false;
   }
   return true;
 }
 
 void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (TryEmitSmiBinaryOp(compiler, this)) {
     // Operation inlined.
     return;
   }
   // TODO(srdjan): Remove this code once BinaryOpComp has been implemeneted
   // for all intended operations.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ pushq(left);
   __ pushq(right);
   InstanceCallComp* instance_call_comp = instance_call();
   instance_call_comp->EmitNativeCode(compiler);
   if (locs()->out().reg() != RAX) {
     __ movq(locs()->out().reg(), RAX);
   }
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64