Inline binary And operation for Mint and Smi in new compilers.

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 1266 matching lines @@
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 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.
   }
+
+  if (operands_type() == kMintOperands) {
+    ASSERT(op_kind() == Token::kBIT_AND);
+    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;
+  }
+
   ASSERT(operands_type() == kSmiOperands);
+
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 3;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RegisterLocation(EAX));
     summary->set_in(1, Location::RegisterLocation(ECX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RegisterLocation(EBX));
     // Will be used for for sign extension.
     summary->set_temp(1, Location::RegisterLocation(EDX));
     summary->set_temp(2, Location::RequiresRegister());
@@ skipping 154 matching lines @@
       UNREACHABLE();
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
+static void EmitMintBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
+  // TODO(regis): For now, we only support Token::kBIT_AND for a Mint or Smi
+  // receiver and a Smi argument.
+  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(),
+                                        kDeoptMintBinaryOp,
+                                        temp,
+                                        right);
+  __ testl(right, Immediate(kSmiTagMask));  // Argument must be Smi.
+  __ j(NOT_ZERO, deopt);
+  __ testl(left, Immediate(kSmiTagMask));  // Receiver can be Smi.
+  Label two_smi;
+  __ j(ZERO, &two_smi);
+  __ CompareClassId(left, kMint, temp);  // Receiver must be Mint.
+  __ j(NOT_EQUAL, deopt);
+
+  ASSERT(comp->op_kind() == Token::kBIT_AND);
+
+  // Load lower Mint word, convert to Smi. It is OK to loose bits.
+  ASSERT(result == left);
+  __ movl(result, FieldAddress(left, Mint::value_offset()));
+  __ SmiTag(result);
+  __ Bind(&two_smi);
+  __ andl(result, right);
+}
+
+
 static void EmitDoubleBinaryOp(FlowGraphCompiler* compiler,
                                BinaryOpComp* comp) {
   Register left = EBX;
   Register right = ECX;
   Register temp = EDX;
   Register result = comp->locs()->out().reg();
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
@@ skipping 28 matching lines @@
   __ 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();
   }
 }
 
 
@@ skipping 216 matching lines @@
   }
   __ Bind(&done);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64