First part of new ICData infrastructure: use a wrapper object instead of an array.

runtime/vm/code_generator.cc

 // Copyright (c) 2011, 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/code_generator.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/exceptions.h"
-#include "vm/ic_data.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, inline_cache, true, "enable inline caches");
 DEFINE_FLAG(bool, trace_deopt, false, "Trace deoptimization");
@@ skipping 496 matching lines @@
     // Special handling so that we do not pollute the inline cache with null
     // classes.
     if (FLAG_trace_ic) {
       OS::Print("InlineCacheMissHandler Null receiver target %s\n",
           target_function.ToCString());
     }
     return target_function.raw();
   }
   DartFrameIterator iterator;
   DartFrame* caller_frame = iterator.NextFrame();
-  ICData ic_data(Array::Handle(
-      CodePatcher::GetInstanceCallIcDataAt(caller_frame->pc())));
-
+  ICData& ic_data = ICData::Handle(
+      CodePatcher::GetInstanceCallIcDataAt(caller_frame->pc()));
 #if defined(DEBUG)
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<const Class*> classes;
     Function& target = Function::Handle();
     ic_data.GetCheckAt(i, &classes, &target);
     bool matches = true;
     for (intptr_t k = 0; k < classes.length(); k++) {
       if (classes[k]->raw() != args[k]->clazz()) {
         matches = false;
         break;
       }
     }
     // Do not add an entry twice!
     ASSERT(!matches);
   }
 #endif  // DEBUG
 
   GrowableArray<const Class*> classes;
-  ASSERT(ic_data.NumberOfArgumentsChecked() == args.length());
+  ASSERT(ic_data.num_args_tested() == args.length());
   for (intptr_t i = 0; i < args.length(); i++) {
     classes.Add(&Class::ZoneHandle(args[i]->clazz()));
   }
   ic_data.AddCheck(classes, target_function);
-  CodePatcher::SetInstanceCallIcDataAt(caller_frame->pc(),
-                                       Array::ZoneHandle(ic_data.data()));
   if (FLAG_trace_ic) {
     OS::Print("InlineCacheMissHandler %d call at 0x%x' adding <%s> -> <%s>\n",
         args.length(),
         caller_frame->pc(),
         Class::Handle(receiver.clazz()).ToCString(),
         target_function.ToCString());
   }
   return target_function.raw();
 }
 
@@ skipping 55 matching lines @@
     }
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 // Resolve an implicit closure by checking if an instance function
 // of the same name exists and creating a closure object of the function.
 // Arg0: receiver object.
-// Arg1: ic-data array.
+// Arg1: ic-data.
 // Returns: Closure object or NULL (instance function not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureFunction, 2) {
   ASSERT(arguments.Count() ==
          kResolveImplicitClosureFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Array& ic_data_array = Array::CheckedHandle(arguments.At(1));
-  ICData ic_data(ic_data_array);
-  const String& original_function_name = String::Handle(ic_data.FunctionName());
+  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const String& original_function_name = String::Handle(ic_data.target_name());
   const String& getter_prefix = String::Handle(String::New("get:"));
   Closure& closure = Closure::Handle();
   if (!original_function_name.StartsWith(getter_prefix)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   Class& receiver_class = Class::Handle();
   receiver_class ^= receiver.clazz();
@@ skipping 20 matching lines @@
         AbstractTypeArguments::Handle(receiver.GetTypeArguments());
     closure.SetTypeArguments(type_arguments);
   }
   arguments.SetReturn(closure);
 }
 
 
 // Resolve an implicit closure by invoking getter and checking if the return
 // value from getter is a closure.
 // Arg0: receiver object.
-// Arg1: ic-data array.
+// Arg1: ic-data.
 // Returns: Closure object or NULL (closure not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureThroughGetter, 2) {
   ASSERT(arguments.Count() ==
          kResolveImplicitClosureThroughGetterRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Array& ic_data_array = Array::CheckedHandle(arguments.At(1));
-  ICData ic_data(ic_data_array);
-  const String& original_function_name = String::Handle(ic_data.FunctionName());
+  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const String& original_function_name = String::Handle(ic_data.target_name());
   const int kNumArguments = 1;
   const int kNumNamedArguments = 0;
   const String& getter_function_name =
       String::Handle(Field::GetterName(original_function_name));
   Function& function = Function::ZoneHandle(
       Resolver::ResolveDynamic(receiver,
                                getter_function_name,
                                kNumArguments,
                                kNumNamedArguments));
   Code& code = Code::Handle();
@@ skipping 100 matching lines @@
                  adjusted_arg_descriptor,
                  invoke_arguments.data(),
                  context));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver.
-// Arg1: ic-data array.
+// Arg1: ic-data.
 // Arg2: original arguments descriptor array.
 // Arg3: original arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodFunction, 4) {
   ASSERT(arguments.Count() ==
          kInvokeNoSuchMethodFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Array& ic_data_array = Array::CheckedHandle(arguments.At(1));
-  ICData ic_data(ic_data_array);
-  const String& original_function_name = String::Handle(ic_data.FunctionName());
+  const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
+  const String& original_function_name = String::Handle(ic_data.target_name());
   ASSERT(!Array::CheckedHandle(arguments.At(2)).IsNull());
   const Array& orig_arguments = Array::CheckedHandle(arguments.At(3));
   // TODO(regis): The signature of the "noSuchMethod" method has to change from
   // noSuchMethod(String name, Array arguments) to something like
   // noSuchMethod(InvocationMirror call).
   const int kNumArguments = 3;
   const int kNumNamedArguments = 0;
   const Array& kNoArgumentNames = Array::Handle();
   const String& function_name =
       String::Handle(String::NewSymbol("noSuchMethod"));
@@ skipping 289 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart