Fall back to megamorphic stub when dispatching calls to rare classes.

runtime/vm/jit_optimizer.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.
 #ifndef DART_PRECOMPILED_RUNTIME
 #include "vm/jit_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 1531 matching lines @@
   }
 
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
 
-  const bool is_dense = CheckClassInstr::IsDenseCidRange(unary_checks);
-  const intptr_t number_of_checks = unary_checks.NumberOfChecks();
-  if (op_kind == Token::kEQ &&
-      number_of_checks > FLAG_max_equality_polymorphic_checks && !is_dense &&
-      flow_graph()->InstanceCallNeedsClassCheck(
-          instr, RawFunction::kRegularFunction)) {
-    // Too many checks, it will be megamorphic which needs unary checks.
-    instr->set_ic_data(&unary_checks);
-    return;
-  }
-
   if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
     return;
   }
 
   if (op_kind == Token::kEQ && TryReplaceWithEqualityOp(instr, op_kind)) {
     return;
   }
@@ skipping 48 matching lines @@
     if (!flow_graph()->InstanceCallNeedsClassCheck(instr, function_kind)) {
       PolymorphicInstanceCallInstr* call =
           new (Z) PolymorphicInstanceCallInstr(instr, unary_checks,
                                                /* call_with_checks = */ false,
                                                /* complete = */ false);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
+  // If there is only one target we can make this into a deopting class check,
+  // followed by a call instruction that does not check the class of the
+  // receiver.  This enables a lot of optimizations because after the class
+  // check we can probably inline the call and not worry about side effects.
+  // However, this can fall down if new receiver classes arrive at this call
+  // site after we generated optimized code.  This causes a deopt, and after a
+  // few deopts we won't optimize this function any more at all.  Therefore for
+  // very polymorphic sites we don't make this optimization, keeping it as a
+  // regular checked PolymorphicInstanceCall, which falls back to the slow but
+  // non-deopting megamorphic call stub when it sees new receiver classes.
   bool call_with_checks;
-  if (has_one_target && FLAG_polymorphic_with_deopt) {
+  if (has_one_target && FLAG_polymorphic_with_deopt &&
+      (!instr->ic_data()->HasDeoptReason(ICData::kDeoptCheckClass) ||
+       unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
     // Type propagation has not run yet, we cannot eliminate the check.
     AddReceiverCheck(instr);
     // Call can still deoptimize, do not detach environment from instr.
     call_with_checks = false;
   } else {
     call_with_checks = true;
   }
   PolymorphicInstanceCallInstr* call = new (Z)
       PolymorphicInstanceCallInstr(instr, unary_checks, call_with_checks,
                                    /* complete = */ false);
@@ skipping 244 matching lines @@
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart
 #endif  // DART_PRECOMPILED_RUNTIME