VM: Small cleanup in optimizer and intrinsics code.

runtime/vm/flow_graph_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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 2249 matching lines @@
     cls = cls.SuperClass();
   }
   return Field::null();
 }
 
 
 // Use CHA to determine if the call needs a class check: if the callee's
 // receiver is the same as the caller's receiver and there are no overriden
 // callee functions, then no class check is needed.
 bool FlowGraphOptimizer::InstanceCallNeedsClassCheck(
-    InstanceCallInstr* call) const {
+    InstanceCallInstr* call, RawFunction::Kind kind) const {
+  ASSERT(kind == RawFunction::kRegularFunction ||
+         kind == RawFunction::kMethodExtractor);
   if (!FLAG_use_cha) return true;
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
+    const String& name = (kind == RawFunction::kMethodExtractor)
+        ? String::Handle(I, Field::NameFromGetter(call->function_name()))
+        : call->function_name();
     return isolate()->cha()->HasOverride(Class::Handle(I, function.Owner()),
-                                         call->function_name());
-  }
-  return true;
-}
-
-
-bool FlowGraphOptimizer::MethodExtractorNeedsClassCheck(
-    InstanceCallInstr* call) const {
-  if (!FLAG_use_cha) return true;
-  Definition* callee_receiver = call->ArgumentAt(0);
-  ASSERT(callee_receiver != NULL);
-  const Function& function = flow_graph_->parsed_function().function();
-  if (function.IsDynamicFunction() &&
-      callee_receiver->IsParameter() &&
-      (callee_receiver->AsParameter()->index() == 0)) {
-    const String& field_name =
-      String::Handle(I, Field::NameFromGetter(call->function_name()));
-    return isolate()->cha()->HasOverride(
-        Class::Handle(I, function.Owner()), field_name);
+                                         name);
   }
   return true;
 }
 
 
 void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
   Function& target = Function::Handle(I);
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
   // Inline implicit instance getter.
   const String& field_name =
       String::Handle(I, Field::NameFromGetter(call->function_name()));
   const Field& field =
       Field::ZoneHandle(I, GetField(class_ids[0], field_name));
   ASSERT(!field.IsNull());
 
-  if (InstanceCallNeedsClassCheck(call)) {
+  if (InstanceCallNeedsClassCheck(call, RawFunction::kRegularFunction)) {
     AddReceiverCheck(call);
   }
   LoadFieldInstr* load = new(I) LoadFieldInstr(
       new(I) Value(call->ArgumentAt(0)),
       &field,
       AbstractType::ZoneHandle(I, field.type()),
       call->token_pos());
   load->set_is_immutable(field.is_final());
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
@@ skipping 1817 matching lines @@
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(I, instr->ic_data()->AsUnaryClassChecks());
 
   intptr_t max_checks = (op_kind == Token::kEQ)
       ? FLAG_max_equality_polymorphic_checks
       : FLAG_max_polymorphic_checks;
   if ((unary_checks.NumberOfChecks() > max_checks) &&
-      InstanceCallNeedsClassCheck(instr)) {
+      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) && TryReplaceWithStoreIndexed(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
     return;
@@ skipping 32 matching lines @@
   if (has_one_target) {
     // Check if the single target is a polymorphic target, if it is,
     // we don't have one target.
     const Function& target =
         Function::Handle(I, unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
 
   if (has_one_target) {
-    const bool is_method_extraction =
-        Function::Handle(I, unary_checks.GetTargetAt(0)).IsMethodExtractor();
-
-    if ((is_method_extraction && !MethodExtractorNeedsClassCheck(instr)) ||
-        (!is_method_extraction && !InstanceCallNeedsClassCheck(instr))) {
+    RawFunction::Kind function_kind =
+        Function::Handle(I, unary_checks.GetTargetAt(0)).kind();
+    if (!InstanceCallNeedsClassCheck(instr, function_kind)) {
       const bool call_with_checks = false;
       PolymorphicInstanceCallInstr* call =
           new(I) PolymorphicInstanceCallInstr(instr, unary_checks,
                                               call_with_checks);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
@@ skipping 241 matching lines @@
     // Non-implicit setter are inlined like normal method calls.
     return false;
   }
   // Inline implicit instance setter.
   const String& field_name =
       String::Handle(I, Field::NameFromSetter(instr->function_name()));
   const Field& field =
       Field::ZoneHandle(I, GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
-  if (InstanceCallNeedsClassCheck(instr)) {
+  if (InstanceCallNeedsClassCheck(instr, RawFunction::kRegularFunction)) {
     AddReceiverCheck(instr);
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlways(kSmiCid, *instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new(I) CheckSmiInstr(
                      new(I) Value(instr->ArgumentAt(1)),
                      instr->deopt_id(),
                      instr->token_pos()),
                  instr->env(),
@@ skipping 5052 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart