Support for mixed null/smi equality: do not deoptimize, emit same optimized code as if that was smi…

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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 212 matching lines @@
                            const GrowableArray<intptr_t>& class_ids) {
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     if (class_ids[i] == class_id) {
       return true;
     }
   }
   return false;
 }
 
 
+// Returns true if ICData tests two arguments and all ICData cids are in the
+// required sets 'receiver_class_ids' or 'argument_class_ids', respectively.
 static bool ICDataHasOnlyReceiverArgumentClassIds(
     const ICData& ic_data,
     const GrowableArray<intptr_t>& receiver_class_ids,
     const GrowableArray<intptr_t>& argument_class_ids) {
   if (ic_data.num_args_tested() != 2) return false;
-
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
   }
@@ skipping 89 matching lines @@
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(InstanceCallInstr* call,
                                        Value* value) {
   // Type propagation has not run yet, we cannot eliminate the check.
   const ICData& unary_checks =
       ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
-  CheckClassInstr* check = new CheckClassInstr(value, call, unary_checks);
+  CheckClassInstr* check =
+      new CheckClassInstr(value, call->deopt_id(), unary_checks);
   InsertBefore(call, check, call->env(), Definition::kEffect);
 }
 
 
 static bool ArgIsAlwaysSmi(const ICData& ic_data, intptr_t arg_n) {
   ASSERT(ic_data.num_args_tested() > arg_n);
   if (ic_data.NumberOfChecks() == 0) return false;
   GrowableArray<intptr_t> class_ids;
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
@@ skipping 718 matching lines @@
   // If one of the inputs is null, no ICdata will be collected.
   if (comp->left()->BindsToConstantNull() ||
       comp->right()->BindsToConstantNull()) {
     Token::Kind strict_kind = (comp->kind() == Token::kEQ) ?
         Token::kEQ_STRICT : Token::kNE_STRICT;
     StrictCompareInstr* strict_comp =
         new StrictCompareInstr(strict_kind, comp->left(), comp->right());
     instr->ReplaceWith(strict_comp, iterator);
     return;
   }
-  if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) return;
+  if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) {
+    return;
+  }
+  ASSERT(comp->ic_data()->num_args_tested() == 2);
   if (comp->ic_data()->NumberOfChecks() == 1) {
-    ASSERT(comp->ic_data()->num_args_tested() == 2);
     GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
     comp->ic_data()->GetCheckAt(0, &class_ids, &target);
     // TODO(srdjan): allow for mixed mode int/double comparison.
 
     if ((class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
       optimizer->InsertBefore(
           instr,
           new CheckSmiInstr(comp->left()->Copy(), comp->deopt_id()),
           instr->env(),
@@ skipping 11 matching lines @@
       comp->set_receiver_class_id(kMintCid);
     } else {
       ASSERT(comp->receiver_class_id() == kIllegalCid);
     }
   } else if (HasTwoMintOrSmi(*comp->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     comp->set_receiver_class_id(kMintCid);
   } else if (comp->ic_data()->AllReceiversAreNumbers()) {
     comp->set_receiver_class_id(kNumberCid);
   }
+
+  if (comp->receiver_class_id() != kIllegalCid) {
+    // Done.
+    return;
+  }
+
+  // Check if ICDData contains checks with Smi/Null combinations. In that case
+  // we can still emit the optimized Smi equality operation but need to add
+  // checks for null or Smi.
+  // TODO(srdjan): Add it for Double and Mint.
+  GrowableArray<intptr_t> smi_or_null(2);
+  smi_or_null.Add(kSmiCid);
+  smi_or_null.Add(kNullCid);
+  if (ICDataHasOnlyReceiverArgumentClassIds(
+        *comp->ic_data(), smi_or_null, smi_or_null)) {
+    ICData& unary_checks =
+        ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
+    const intptr_t deopt_id = comp->deopt_id();
+    if ((unary_checks.NumberOfChecks() == 1) &&
+        (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
+      // Smi only.
+      optimizer->InsertBefore(
+        instr,
+        new CheckSmiInstr(comp->left()->Copy(), deopt_id),
+        instr->env(),
+        Definition::kEffect);
+    } else {
+      // Smi or NULL.
+      optimizer->InsertBefore(
+        instr,
+        new CheckClassInstr(comp->left()->Copy(), deopt_id, unary_checks),
+        instr->env(),
+        Definition::kEffect);
+    }
+
+    unary_checks = comp->ic_data()->AsUnaryClassChecksForArgNr(1);
+    if ((unary_checks.NumberOfChecks() == 1) &&
+        (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
+      // Smi only.
+      optimizer->InsertBefore(
+        instr,
+        new CheckSmiInstr(comp->right()->Copy(), deopt_id),
+        instr->env(),
+        Definition::kEffect);
+    } else {
+      // Smi or NULL.
+      optimizer->InsertBefore(
+        instr,
+        new CheckClassInstr(comp->right()->Copy(), deopt_id, unary_checks),
+        instr->env(),
+        Definition::kEffect);
+    }
+    comp->set_receiver_class_id(kSmiCid);
+  }
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareInstr* instr) {
   HandleEqualityCompare(this, instr, instr, current_iterator());
 }
 
 
 void FlowGraphOptimizer::VisitBranch(BranchInstr* instr) {
   ComparisonInstr* comparison = instr->comparison();
@@ skipping 2040 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart