Eliminated with_checks variable

runtime/vm/aot_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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 111 matching lines @@
                               cls, call->function_name(), args_desc));
   ASSERT(!function.IsNull());
 
   ZoneGrowableArray<PushArgumentInstr*>* args =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(call->PushArgumentAt(i));
   }
   StaticCallInstr* static_call = new (Z) StaticCallInstr(
       call->token_pos(), Function::ZoneHandle(Z, function.raw()),
-      call->argument_names(), args, call->deopt_id());
+      call->argument_names(), args, call->deopt_id(), call->CallCount());
   static_call->set_result_cid(kTypeCid);
   call->ReplaceWith(static_call, current_iterator());
   return true;
 }
 
 
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
 // have no runtime type feedback collected.
@@ skipping 502 matching lines @@
     PushArgumentInstr* arg =
         new (Z) PushArgumentInstr(new (Z) Value(left->ArgumentAt(0)));
     InsertBefore(call, arg, NULL, FlowGraph::kEffect);
     args->Add(arg);
     arg = new (Z) PushArgumentInstr(new (Z) Value(right->ArgumentAt(0)));
     InsertBefore(call, arg, NULL, FlowGraph::kEffect);
     args->Add(arg);
     StaticCallInstr* static_call =
         new (Z) StaticCallInstr(call->token_pos(), have_same_runtime_type,
                                 Object::null_array(),  // argument_names
-                                args, call->deopt_id());
+                                args, call->deopt_id(), call->CallCount());
     static_call->set_result_cid(kBoolCid);
     ReplaceCall(call, static_call);
     return true;
   }
 
   return false;
 }
 
 
 bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
@@ skipping 845 matching lines @@
           Library::Handle(Z, Library::InternalLibrary());
       const String& target_name = Symbols::_classRangeCheck();
       const Function& target = Function::ZoneHandle(
           Z, dart_internal.LookupFunctionAllowPrivate(target_name));
       ASSERT(!target.IsNull());
       ASSERT(target.IsRecognized() && target.always_inline());
 
       StaticCallInstr* new_call =
           new (Z) StaticCallInstr(call->token_pos(), target,
                                   Object::null_array(),  // argument_names
-                                  args, call->deopt_id());
+                                  args, call->deopt_id(), call->CallCount());
       Environment* copy = call->env()->DeepCopy(
           Z, call->env()->Length() - call->ArgumentCount());
       for (intptr_t i = 0; i < args->length(); ++i) {
         copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
       }
       call->RemoveEnvironment();
       ReplaceCall(call, new_call);
       copy->DeepCopyTo(Z, new_call);
       return;
     }
@@ skipping 71 matching lines @@
     const String& target_name = Symbols::_classIdEqualsAssert();
     const Function& target = Function::ZoneHandle(
         Z, dart_internal.LookupFunctionAllowPrivate(target_name));
     ASSERT(!target.IsNull());
     ASSERT(target.IsRecognized());
     ASSERT(target.always_inline());
 
     StaticCallInstr* new_call =
         new (Z) StaticCallInstr(call->token_pos(), target,
                                 Object::null_array(),  // argument_names
-                                args, call->deopt_id());
+                                args, call->deopt_id(), call->CallCount());
     Environment* copy =
         call->env()->DeepCopy(Z, call->env()->Length() - call->ArgumentCount());
     for (intptr_t i = 0; i < args->length(); ++i) {
       copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
     }
     call->RemoveEnvironment();
     ReplaceCall(call, new_call);
     copy->DeepCopyTo(Z, new_call);
     return;
   }
@@ skipping 42 matching lines @@
       const String& target_name = Symbols::_classRangeAssert();
       const Function& target = Function::ZoneHandle(
           Z, dart_internal.LookupFunctionAllowPrivate(target_name));
       ASSERT(!target.IsNull());
       ASSERT(target.IsRecognized());
       ASSERT(target.always_inline());
 
       StaticCallInstr* new_call =
           new (Z) StaticCallInstr(call->token_pos(), target,
                                   Object::null_array(),  // argument_names
-                                  args, call->deopt_id());
+                                  args, call->deopt_id(), call->CallCount());
       Environment* copy = call->env()->DeepCopy(
           Z, call->env()->Length() - call->ArgumentCount());
       for (intptr_t i = 0; i < args->length(); ++i) {
         copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
       }
       call->RemoveEnvironment();
       ReplaceCall(call, new_call);
       copy->DeepCopyTo(Z, new_call);
       return;
     }
@@ skipping 149 matching lines @@
     const Function& target = Function::Handle(Z, unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
 
   if (has_one_target) {
     RawFunction::Kind function_kind =
         Function::Handle(Z, unary_checks.GetTargetAt(0)).kind();
     if (!flow_graph()->InstanceCallNeedsClassCheck(instr, function_kind)) {
       CallTargets* targets = CallTargets::Create(Z, unary_checks);
-      PolymorphicInstanceCallInstr* call =
-          new (Z) PolymorphicInstanceCallInstr(instr, *targets,
-                                               /* with_checks = */ false,
-                                               /* complete = */ true);
+      ASSERT(targets->HasSingleTarget());
+      const Function& target = targets->FirstTarget();
+      ZoneGrowableArray<PushArgumentInstr*>* args =

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

This pattern (creaet array - copy push arguments create static call) occurs
multiple times in the code base. 

Maybe make a helper, for example:

FlowGraph::ReplaceCallWithStaticCall(...)

Alternatively you can have a static method on StaticCallInstr, e.g.

// I am not sure about the name
StaticCallInstr* FromCall( ) {
}

that encapsulates most of this, and then just do:

instr->ReplaceWith(StaticCallInstr::FromCall(call, ....), ...)

+          new (Z) ZoneGrowableArray<PushArgumentInstr*>(instr->ArgumentCount());
+      for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
+        args->Add(instr->PushArgumentAt(i));
+      }
+      StaticCallInstr* call = new (Z)
+          StaticCallInstr(instr->token_pos(), target, instr->argument_names(),
+                          args, instr->deopt_id(), instr->CallCount());
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
   switch (instr->token_kind()) {
     case Token::kEQ:
     case Token::kLT:
     case Token::kLTE:
     case Token::kGT:
     case Token::kGTE: {
@@ skipping 42 matching lines @@
         Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
 
     const Array& args_desc_array =
         Array::Handle(Z, ArgumentsDescriptor::New(instr->ArgumentCount(),
                                                   instr->argument_names()));
     ArgumentsDescriptor args_desc(args_desc_array);
     Function& function = Function::Handle(
         Z, Resolver::ResolveDynamicForReceiverClass(
                receiver_class, instr->function_name(), args_desc));
     if (!function.IsNull()) {
-      CallTargets* targets = new (Z) CallTargets();
       Function& target = Function::ZoneHandle(Z, function.raw());

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

same pattern

-      targets->Add(CidRangeTarget(receiver_class.id(), receiver_class.id(),
-                                  &target, /*count = */ 1));
-      PolymorphicInstanceCallInstr* call =
-          new (Z) PolymorphicInstanceCallInstr(instr, *targets,
-                                               /* with_checks = */ false,
-                                               /* complete = */ true);
+      ZoneGrowableArray<PushArgumentInstr*>* args =
+          new (Z) ZoneGrowableArray<PushArgumentInstr*>(instr->ArgumentCount());
+      for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
+        args->Add(instr->PushArgumentAt(i));
+      }
+      StaticCallInstr* call = new (Z)
+          StaticCallInstr(instr->token_pos(), target, instr->argument_names(),
+                          args, instr->deopt_id(), instr->CallCount());
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   Definition* callee_receiver = instr->ArgumentAt(0);
   const Function& function = flow_graph_->function();
   Class& receiver_class = Class::Handle(Z);
 
   if (function.IsDynamicFunction() &&
@@ skipping 88 matching lines @@
           ic_data.AddReceiverCheck(cls.id(), single_target);
           instr->set_ic_data(&ic_data);
 
           if (TryInlineFieldAccess(instr)) {
             return;
           }
         }
 
         // We have computed that there is only a single target for this call
         // within the whole hierarchy. Replace InstanceCall with StaticCall.
         ZoneGrowableArray<PushArgumentInstr*>* args = new (Z)

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

same pattern

             ZoneGrowableArray<PushArgumentInstr*>(instr->ArgumentCount());
         for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
           args->Add(instr->PushArgumentAt(i));
         }
         StaticCallInstr* call = new (Z) StaticCallInstr(
             instr->token_pos(), Function::ZoneHandle(Z, single_target.raw()),
-            instr->argument_names(), args, instr->deopt_id());
+            instr->argument_names(), args, instr->deopt_id(),
+            instr->CallCount());
         instr->ReplaceWith(call, current_iterator());
         return;
       } else if ((ic_data.raw() != ICData::null()) &&
                  !ic_data.NumberOfChecksIs(0)) {
         CallTargets* targets = CallTargets::Create(Z, ic_data);
         PolymorphicInstanceCallInstr* call =
             new (Z) PolymorphicInstanceCallInstr(instr, *targets,
-                                                 /* with_checks = */ true,
                                                  /* complete = */ true);
         instr->ReplaceWith(call, current_iterator());
         return;
       }
     }
   }
 
   // More than one target. Generate generic polymorphic call without
   // deoptimization.
   if (instr->ic_data()->NumberOfUsedChecks() > 0) {
     ASSERT(!FLAG_polymorphic_with_deopt);
     // OK to use checks with PolymorphicInstanceCallInstr since no
     // deoptimization is allowed.
     CallTargets* targets = CallTargets::Create(Z, *instr->ic_data());
     PolymorphicInstanceCallInstr* call =
         new (Z) PolymorphicInstanceCallInstr(instr, *targets,
-                                             /* with_checks = */ true,
                                              /* complete = */ false);
     instr->ReplaceWith(call, current_iterator());
     return;
   }
 }
 
 
 void AotOptimizer::VisitPolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
-  if (call->with_checks()) {
-    const intptr_t receiver_cid =
-        call->PushArgumentAt(0)->value()->Type()->ToCid();
-    if (receiver_cid != kDynamicCid) {
-      const Class& receiver_class =
-          Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
+  const intptr_t receiver_cid =
+      call->PushArgumentAt(0)->value()->Type()->ToCid();
+  if (receiver_cid != kDynamicCid) {
+    const Class& receiver_class =
+        Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
 
-      const Array& args_desc_array = Array::Handle(
-          Z, ArgumentsDescriptor::New(call->ArgumentCount(),
-                                      call->instance_call()->argument_names()));
-      ArgumentsDescriptor args_desc(args_desc_array);
-      const Function& function = Function::Handle(
-          Z, Resolver::ResolveDynamicForReceiverClass(
-                 receiver_class, call->instance_call()->function_name(),
-                 args_desc));
-      if (!function.IsNull()) {
-        call->set_with_checks(false);
+    const Array& args_desc_array = Array::Handle(
+        Z, ArgumentsDescriptor::New(call->ArgumentCount(),
+                                    call->instance_call()->argument_names()));
+    ArgumentsDescriptor args_desc(args_desc_array);
+    const Function& function = Function::Handle(
+        Z,
+        Resolver::ResolveDynamicForReceiverClass(
+            receiver_class, call->instance_call()->function_name(), args_desc));
+    if (!function.IsNull()) {
+      // Only one target. Replace by static call.

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

same pattern

+      ZoneGrowableArray<PushArgumentInstr*>* args =
+          new (Z) ZoneGrowableArray<PushArgumentInstr*>(
+              call->instance_call()->ArgumentCount());
+      for (intptr_t i = 0; i < call->instance_call()->ArgumentCount(); i++) {
+        args->Add(call->instance_call()->PushArgumentAt(i));
       }
+      StaticCallInstr* new_call = new (Z) StaticCallInstr(
+          call->token_pos(), function, call->instance_call()->argument_names(),
+          args, call->deopt_id(), call->CallCount());
+      call->ReplaceWith(new_call, current_iterator());
     }
   }
 }
 
 
 void AotOptimizer::VisitStaticCall(StaticCallInstr* call) {
   if (!IsAllowedForInlining(call->deopt_id())) {
     // Inlining disabled after a speculative inlining attempt.
     return;
   }
@@ skipping 157 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart