Use call counts to determine which static calls to inline.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
@@ skipping 2096 matching lines @@
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call =
       new StaticCallInstr(node->token_pos(),
                           node->function(),
                           node->arguments()->names(),
-                          arguments);
+                          arguments,
+                          owner()->ic_data_array());
   if (node->function().is_native()) {
     const intptr_t result_cid = GetResultCidOfNative(node->function());
     call->set_result_cid(result_cid);
   }
   ReturnDefinition(call);
 }
 
 
 ClosureCallInstr* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
@@ skipping 89 matching lines @@
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallInstr(node->token_pos(),
                          node->constructor(),
                          node->arguments()->names(),
-                         arguments));
+                         arguments,
+                         owner()->ic_data_array()));
 }
 
 
 // Class that recognizes factories and returns corresponding result cid.
 class FactoryRecognizer : public AllStatic {
  public:
   // Return kDynamicCid if factory is not recognized.
   static intptr_t ResultCid(const Function& factory) {
     ASSERT(factory.IsFactory());
     const Class& function_class = Class::Handle(factory.Owner());
@@ skipping 47 matching lines @@
     PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     StaticCallInstr* call =
         new StaticCallInstr(node->token_pos(),
                             node->constructor(),
                             node->arguments()->names(),
-                            arguments);
+                            arguments,
+                            owner()->ic_data_array());
     const intptr_t result_cid = GetResultCidOfListFactory(node);
     if (result_cid != kDynamicCid) {
       call->set_result_cid(result_cid);
       call->set_is_known_list_constructor(true);
       // Recognized fixed length array factory must have two arguments:
       // (0) type-arguments, (1) length.
       ASSERT(!LoadFieldInstr::IsFixedLengthArrayCid(result_cid) ||
              arguments->length() == 2);
     }
     ReturnDefinition(call);
@@ skipping 334 matching lines @@
                   InvocationMirror::kStatic,
               InvocationMirror::kGetter));
       ReturnDefinition(call);
       return;
     }
   }
   ASSERT(!getter_function.IsNull());
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
                                               Object::null_array(),  // No names
-                                              arguments);
+                                              arguments,
+                                              owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
@@ skipping 46 matching lines @@
     if (result_is_needed) {
       value = Bind(BuildStoreExprTemp(for_value.value()));
     } else {
       value = for_value.value();
     }
     arguments->Add(PushArgument(value));
 
     call = new StaticCallInstr(node->token_pos(),
                                setter_function,
                                Object::null_array(),  // No names.
-                               arguments);
+                               arguments,
+                               owner()->ic_data_array());
   }
   if (result_is_needed) {
     Do(call);
     ReturnDefinition(BuildLoadExprTemp());
   } else {
     ReturnDefinition(call);
   }
 }
 
 
@@ skipping 200 matching lines @@
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new StaticCallInstr(node->token_pos(),
                                                 *super_function,
                                                 Object::null_array(),
-                                                arguments);
+                                                arguments,
+                                                owner()->ic_data_array());
     ReturnDefinition(load);
   } else {
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
     InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
                                                     Symbols::IndexToken(),
                                                     Token::kINDEX,
                                                     arguments,
                                                     Object::null_array(),
                                                     checked_argument_count,
@@ skipping 58 matching lines @@
   }
   arguments->Add(PushArgument(value));
 
   if (super_function != NULL) {
     // Generate static call to super operator []=.
 
     StaticCallInstr* store =
         new StaticCallInstr(node->token_pos(),
                             *super_function,
                             Object::null_array(),
-                            arguments);
+                            arguments,
+                            owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 3;
     const String& name =
@@ skipping 291 matching lines @@
   const Function& no_such_method_func = Function::ZoneHandle(
       Resolver::ResolveDynamicAnyArgs(target_class, Symbols::NoSuchMethod()));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
   return new StaticCallInstr(args_pos,
                              no_such_method_func,
                              Object::null_array(),
-                             push_arguments);
+                             push_arguments,
+                             owner()->ic_data_array());
 }
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     intptr_t token_pos,
     const Class& function_class,
     const String& function_name,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
@@ skipping 35 matching lines @@
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               PrivateCoreLibName(Symbols::ThrowNew()),
                               arguments->length(),
                               Object::null_array(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Object::null_array(),  // No names.
-                             arguments);
+                             arguments,
+                             owner()->ic_data_array());
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   ValueGraphVisitor for_exception(owner(), temp_index());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
@@ skipping 109 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart