Remove the IC data array from the isolate.

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/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 24 matching lines @@
 
 
 static const String& PrivateCoreLibName(const String& str) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
   return private_name;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function,
+                                   const Array& ic_data_array,
                                    InlineExitCollector* exit_collector)
   : parsed_function_(parsed_function),
+    ic_data_array_(ic_data_array),
     num_copied_params_(parsed_function.num_copied_params()),
     // All parameters are copied if any parameter is.
     num_non_copied_params_((num_copied_params_ == 0)
         ? parsed_function.function().num_fixed_parameters()
         : 0),
     num_stack_locals_(parsed_function.num_stack_locals()),
     exit_collector_(exit_collector),
     last_used_block_id_(0),  // 0 is used for the graph entry.
     context_level_(0),
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
@@ skipping 862 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(),
-                                                  2);
+                                                  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.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
@@ skipping 221 matching lines @@
                                                          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.
-      kNumArgsChecked);
+      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.
   ValueGraphVisitor for_value(owner(), temp_index());
   node->left()->Visit(&for_value);
@@ skipping 48 matching lines @@
     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.
-        kNumArgsChecked);
+        kNumArgsChecked,
+        owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
@@ skipping 24 matching lines @@
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     if (FLAG_enable_type_checks) {
       EqualityCompareInstr* comp = new EqualityCompareInstr(
           node->token_pos(),
           Token::kEQ,
           for_left_value.value(),
-          for_right_value.value());
+          for_right_value.value(),
+          owner()->ic_data_array());
       if (node->kind() == Token::kEQ) {
         ReturnDefinition(comp);
       } else {
         Value* eq_result = Bind(comp);
         eq_result = Bind(new AssertBooleanInstr(node->token_pos(), eq_result));
         ReturnDefinition(new BooleanNegateInstr(eq_result));
       }
     } else {
       EqualityCompareInstr* comp = new EqualityCompareInstr(
           node->token_pos(),
           node->kind(),
           for_left_value.value(),
-          for_right_value.value());
+          for_right_value.value(),
+          owner()->ic_data_array());
       ReturnDefinition(comp);
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   RelationalOpInstr* comp = new RelationalOpInstr(node->token_pos(),
                                                   node->kind(),
                                                   for_left_value.value(),
-                                                  for_right_value.value());
+                                                  for_right_value.value(),
+                                                  owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
@@ skipping 14 matching lines @@
   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(),
-                            1);
+                            1,
+                            owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
@@ skipping 547 matching lines @@
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->length() + 1);
   arguments->Add(push_receiver);
 
   BuildPushArguments(*node->arguments(), arguments);
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
-      node->arguments()->names(), 1);
+      node->arguments()->names(),
+      1,
+      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 static intptr_t GetResultCidOfNative(const Function& function) {
   const Class& function_class = Class::Handle(function.Owner());
   if (function_class.library() == Library::TypedDataLibrary()) {
     const String& function_name = String::Handle(function.name());
     if (!String::EqualsIgnoringPrivateKey(function_name, Symbols::_New())) {
       return kDynamicCid;
@@ skipping 423 matching lines @@
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   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(), 1);
+      node->token_pos(),
+      name,
+      Token::kGET,
+      arguments, Array::ZoneHandle(),
+      1,
+      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
@@ skipping 18 matching lines @@
   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(),
-                                                  2);  // Checked arg count.
+                                                  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(),
-                           2));  // Checked argument count.
+                           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 =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
@@ skipping 344 matching lines @@
                                                 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(),
-                                                    checked_argument_count);
+                                                    checked_argument_count,
+                                                    owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   Function* super_function = NULL;
   if (node->IsSuperStore()) {
@@ skipping 78 matching lines @@
     // 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(),
-                              checked_argument_count);
+                              checked_argument_count,
+                              owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp();
     } else {
       return store;
     }
   }
 }
 
 
@@ skipping 484 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