Store arguments descriptor in ICData. Remove loading of arguments descriptor at unoptimized call si…

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 961 matching lines @@
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = String::ZoneHandle(Symbols::New(node->Name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   node->kind(),
                                                   arguments,
-                                                  Array::ZoneHandle(),
+                                                  Object::null_array(),
                                                   2,
                                                   owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
@@ skipping 223 matching lines @@
   const Bool& negate = (node->kind() == Token::kISNOT) ? Bool::True() :
                                                          Bool::False();
   Value* negate_arg = Bind(new ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(),
       arguments,
-      Array::ZoneHandle(),  // No argument names.
+      Object::null_array(),  // No argument names.
       kNumArgsChecked,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
@@ skipping 49 matching lines @@
     arguments->Add(push_instantiator);
     arguments->Add(push_type_args);
     Value* type_arg = Bind(new ConstantInstr(type));
     arguments->Add(PushArgument(type_arg));
     const intptr_t kNumArgsChecked = 1;
     InstanceCallInstr* call = new InstanceCallInstr(
         node->token_pos(),
         PrivateCoreLibName(Symbols::_as()),
         node->kind(),
         arguments,
-        Array::ZoneHandle(),  // No argument names.
+        Object::null_array(),  // No argument names.
         kNumArgsChecked,
         owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
@@ skipping 93 matching lines @@
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   InstanceCallInstr* call =
       new InstanceCallInstr(node->token_pos(),
                             String::ZoneHandle(
                                 Symbols::New(Token::Str(node->kind()))),
                             node->kind(),
                             arguments,
-                            Array::ZoneHandle(),
+                            Object::null_array(),
                             1,
                             owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
@@ skipping 1098 matching lines @@
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       name,
       Token::kGET,
-      arguments, Array::ZoneHandle(),
+      arguments, Object::null_array(),
       1,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
@@ skipping 19 matching lines @@
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kSET,
                                                   arguments,
-                                                  Array::ZoneHandle(),
+                                                  Object::null_array(),
                                                   2,  // Checked arg count.
                                                   owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   Do(new InstanceCallInstr(node->token_pos(),
                            name,
                            Token::kSET,
                            arguments,
-                           Array::ZoneHandle(),
+                           Object::null_array(),
                            2,  // Checked argument count.
                            owner()->ic_data_array()));
   ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
@@ skipping 48 matching lines @@
                   InvocationMirror::kTopLevel :
                   InvocationMirror::kStatic,
               InvocationMirror::kGetter));
       ReturnDefinition(call);
       return;
     }
   }
   ASSERT(!getter_function.IsNull());
   StaticCallInstr* call = new StaticCallInstr(node->token_pos(),
                                               getter_function,
-                                              Array::ZoneHandle(),  // No names.
+                                              Object::null_array(),  // No names
                                               arguments);
   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 =
@@ skipping 46 matching lines @@
     Value* value = NULL;
     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,
-                               Array::ZoneHandle(),  // No names.
+                               Object::null_array(),  // No names.
                                arguments);
   }
   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,
-                                                Array::ZoneHandle(),
+                                                Object::null_array(),
                                                 arguments);
     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,
-                                                    Array::ZoneHandle(),
+                                                    Object::null_array(),
                                                     checked_argument_count,
                                                     owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
@@ skipping 48 matching lines @@
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   if (super_function != NULL) {
     // Generate static call to super operator []=.
 
     StaticCallInstr* store =
         new StaticCallInstr(node->token_pos(),
                             *super_function,
-                            Array::ZoneHandle(),
+                            Object::null_array(),
                             arguments);
     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 =
         String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
     InstanceCallInstr* store =
         new InstanceCallInstr(node->token_pos(),
                               name,
                               Token::kASSIGN_INDEX,
                               arguments,
-                              Array::ZoneHandle(),
+                              Object::null_array(),
                               checked_argument_count,
                               owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   }
 }
@@ skipping 273 matching lines @@
                                          temp);
   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,
-                             Array::ZoneHandle(),
+                             Object::null_array(),
                              push_arguments);
 }
 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.
@@ skipping 30 matching lines @@
   arguments->Add(PushArgument(existing_argument_names_value));
   // Resolve and call NoSuchMethodError._throwNew.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::Handle(
       core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               PrivateCoreLibName(Symbols::ThrowNew()),
                               arguments->length(),
-                              Array::ZoneHandle(),
+                              Object::null_array(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
-                             Array::ZoneHandle(),  // No names.
+                             Object::null_array(),  // No names.
                              arguments);
 }
 
 
 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;
@@ skipping 110 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