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

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
@@ skipping 17 matching lines @@
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     Instruction* instr = block_order_[i]->Accept(this);
     // Optimize all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
   }
 }
 
 
-static bool ICDataHasReceiverClass(const ICData& ic_data, const Class& cls) {
-  ASSERT(!cls.IsNull());
+static bool ICDataHasReceiverClass(const ICData& ic_data, intptr_t class_id) {
   ASSERT(ic_data.num_args_tested() > 0);
   Class& test_class = Class::Handle();
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     ic_data.GetOneClassCheckAt(i, &test_class, &target);
-    if (cls.raw() == test_class.raw()) {
+    if (test_class.id() == class_id) {
       return true;
     }
   }
   return false;
 }
 
 
-static bool ICDataHasTwoReceiverClasses(const ICData& ic_data,
-                                        const Class& cls1,
-                                        const Class& cls2) {
-  ASSERT(!cls1.IsNull() && !cls2.IsNull());
+static bool ICDataHasReceiverArgumentClasses(const ICData& ic_data,
+                                             intptr_t receiver_class_id,
+                                             intptr_t argument_class_id) {
   if (ic_data.num_args_tested() != 2) {
     return false;
   }
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<const Class*> classes;
     ic_data.GetCheckAt(i, &classes, &target);
     ASSERT(classes.length() == 2);
-    if (classes[0]->raw() == cls1.raw()) {
-      if (classes[1]->raw() == cls2.raw()) {
+    if (classes[0]->id() == receiver_class_id) {
+      if (classes[1]->id() == argument_class_id) {
         return true;
       }
     }
   }
   return false;
 }
 
 
 static bool HasOneSmi(const ICData& ic_data) {
-  const Class& smi_class =
-      Class::Handle(Isolate::Current()->object_store()->smi_class());
-  return ICDataHasReceiverClass(ic_data, smi_class);
+  return ICDataHasReceiverClass(ic_data, kSmi);
 }
 
 
 static bool HasTwoSmi(const ICData& ic_data) {
-  const Class& smi_class =
-      Class::Handle(Isolate::Current()->object_store()->smi_class());
-  return ICDataHasTwoReceiverClasses(ic_data, smi_class, smi_class);
+  return ICDataHasReceiverArgumentClasses(ic_data, kSmi, kSmi);
+}
+
+
+static bool HasMintSmi(const ICData& ic_data) {
+  return ICDataHasReceiverArgumentClasses(ic_data, kMint, kSmi);
 }
 
 
 static bool HasOneDouble(const ICData& ic_data) {
-  const Class& double_class =
-      Class::Handle(Isolate::Current()->object_store()->double_class());
-  return ICDataHasReceiverClass(ic_data, double_class);
+  return ICDataHasReceiverClass(ic_data, kDouble);
 }
 
 
 static bool HasTwoDouble(const ICData& ic_data) {
-  const Class& double_class =
-      Class::Handle(Isolate::Current()->object_store()->double_class());
-  return ICDataHasTwoReceiverClasses(ic_data, double_class, double_class);
+  return ICDataHasReceiverArgumentClasses(ic_data, kDouble, kDouble);
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
+  BinaryOpComp::OperandsType operands_type;
+
+  if (HasMintSmi(*comp->ic_data())) {
+    // We check for Mint receiver and Smi argument, but we try to support any
+    // combination of Mint and Smi.
+    if (op_kind != Token::kBIT_AND) {
+      // TODO(regis): Not yet supported.
+      return false;
+    }
+
+    operands_type = BinaryOpComp::kMintOperands;
+  }
+
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
     return false;
   }
 
-  BinaryOpComp::OperandsType operands_type;
-
   if (HasTwoSmi(*comp->ic_data())) {
     if (op_kind == Token::kDIV ||
         op_kind == Token::kMOD) {
       // TODO(srdjan): Not yet supported.
       return false;
     }
 
     operands_type = BinaryOpComp::kSmiOperands;
   } else if (HasTwoDouble(*comp->ic_data())) {
     if (op_kind != Token::kADD &&
@@ skipping 463 matching lines @@
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this);
 }
 
 
 }  // namespace dart