VM: Remove unused IsClosureCall bit from IC data.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 688 matching lines @@
 
 
 // An instance call of the form o.f(...) could not be resolved.  Check if
 // there is a getter with the same name.  If so, invoke it.  If the value is
 // a closure, invoke it with the given arguments.  If the value is a
 // non-closure, attempt to invoke "call" on it.
 static bool ResolveCallThroughGetter(const Instance& receiver,
                                      const Class& receiver_class,
                                      const String& target_name,
                                      const Array& arguments_descriptor,
-                                     const ICData& ic_data,
                                      Function* result) {
   // 1. Check if there is a getter with the same name.
   const String& getter_name = String::Handle(Field::GetterName(target_name));
   const int kNumArguments = 1;
   ArgumentsDescriptor args_desc(
       Array::Handle(ArgumentsDescriptor::New(kNumArguments)));
   const Function& getter = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(receiver_class,
                                                getter_name,
                                                args_desc));
@@ skipping 25 matching lines @@
   const Array& args_descriptor = Array::Handle(ic_data.arguments_descriptor());
 
   const Class& receiver_class = Class::Handle(receiver.clazz());
   const String& target_name = String::Handle(ic_data.target_name());
 
   Function& result = Function::Handle();
   if (!ResolveCallThroughGetter(receiver,
                                 receiver_class,
                                 target_name,
                                 args_descriptor,
-                                ic_data,
                                 &result)) {
     ArgumentsDescriptor desc(args_descriptor);
     const Function& target_function =
         Function::Handle(receiver_class.GetInvocationDispatcher(
             target_name,
             args_descriptor,
             RawFunction::kNoSuchMethodDispatcher));
     if (FLAG_trace_ic) {
       OS::PrintErr("NoSuchMethod IC miss: adding <%s> id:%" Pd " -> <%s>\n",
           Class::Handle(receiver.clazz()).ToCString(),
@@ skipping 14 matching lines @@
   String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
   Function& target_function = Function::Handle(
       Resolver::ResolveDynamic(receiver, function_name, arguments_descriptor));
   if (target_function.IsNull()) {
     if (FLAG_trace_ic) {
       OS::PrintErr("InlineCacheMissHandler NULL function for %s receiver: %s\n",
                    String::Handle(ic_data.target_name()).ToCString(),
                    receiver.ToCString());
     }
-    ic_data.SetIsClosureCall();
     target_function = InlineCacheMissHelper(receiver, ic_data);
   }
   ASSERT(!target_function.IsNull());
   if (args.length() == 1) {
     ic_data.AddReceiverCheck(args[0]->GetClassId(), target_function);
   } else {
     GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.NumArgsTested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(args[i]->GetClassId());
@@ skipping 181 matching lines @@
     OS::PrintErr("Megamorphic IC miss, class=%s, function=%s\n",
                  cls.ToCString(), name.ToCString());
   }
 
   ArgumentsDescriptor args_desc(descriptor);
   Function& target_function = Function::Handle(
       Resolver::ResolveDynamicForReceiverClass(cls,
                                                name,
                                                args_desc));
   if (target_function.IsNull()) {
-    ic_data.SetIsClosureCall();
     target_function = InlineCacheMissHelper(receiver, ic_data);
   }
 
   ASSERT(!target_function.IsNull());
   // Insert function found into cache and return it.
   cache.EnsureCapacity();
   const Smi& class_id = Smi::Handle(Smi::New(cls.id()));
   cache.Insert(class_id, target_function);
   arguments.SetReturn(target_function);
 }
@@ skipping 248 matching lines @@
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
-      " %s %s\n",
+      " %s\n",
       frame->pc(),
       ic_data.raw(),
       function.usage_counter(),
       ic_data.NumberOfChecks(),
-      ic_data.IsClosureCall() ? "closure" : "",
       function.ToFullyQualifiedCString());
 }
 
 
 // This is called from function that needs to be optimized.
 // The requesting function can be already optimized (reoptimization).
 // Returns the Code object where to continue execution.
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
   const Function& function = Function::CheckedHandle(isolate,
                                                      arguments.ArgAt(0));
@@ skipping 304 matching lines @@
   field.RecordStore(value);
 }
 
 
 DEFINE_RUNTIME_ENTRY(InitStaticField, 1) {
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   field.EvaluateInitializer();
 }
 
 }  // namespace dart