Precompilation: Generate instance calls as IC calls that can switch to Megamoprhic calls.

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/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 43 matching lines @@
     "Trace IC miss in optimized code");
 DEFINE_FLAG(bool, trace_optimized_ic_calls, false,
     "Trace IC calls in optimized code.");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(bool, trace_type_checks, false, "Trace runtime type checks.");
 
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
+DECLARE_FLAG(int, max_polymorphic_checks);
 
 DEFINE_FLAG(bool, use_osr, true, "Use on-stack replacement.");
 DEFINE_FLAG(bool, trace_osr, false, "Trace attempts at on-stack replacement.");
 
 DEFINE_FLAG(int, stacktrace_every, 0,
             "Compute debugger stacktrace on every N stack overflow checks");
 DEFINE_FLAG(charp, stacktrace_filter, NULL,
             "Compute stacktrace in named function on stack overflow checks");
 DEFINE_FLAG(int, deoptimize_every, 0,
             "Deoptimize on every N stack overflow checks");
@@ skipping 698 matching lines @@
         target_function.IsNull() ? "null" : target_function.ToCString());
   }
   *result = target_function.raw();
   return true;
 }
 
 
 // Handle other invocations (implicit closures, noSuchMethod).
 RawFunction* InlineCacheMissHelper(
     const Instance& receiver,
-    const ICData& ic_data) {
-  const Array& args_descriptor = Array::Handle(ic_data.arguments_descriptor());
-
+    const Array& args_descriptor,
+    const String& target_name) {
   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,
                                 &result)) {
     ArgumentsDescriptor desc(args_descriptor);
     const Function& target_function =
         Function::Handle(receiver_class.GetInvocationDispatcher(
@@ skipping 24 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());
     }
-    target_function = InlineCacheMissHelper(receiver, ic_data);
+    const Array& args_descriptor =
+        Array::Handle(ic_data.arguments_descriptor());
+    const String& target_name = String::Handle(ic_data.target_name());
+    target_function = InlineCacheMissHelper(receiver,
+                                            args_descriptor,
+                                            target_name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
     return target_function.raw();
   }
   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());
@@ skipping 159 matching lines @@
     OS::PrintErr("StaticCallMissHandler at %#" Px
                  " target %s (%" Pd ", %" Pd ")\n",
                  caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
   }
   arguments.SetReturn(target);
 }
 
 
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Arg1: ICData object.

[srdjan, 2015/11/03 22:30:49]

or cache

[rmacnak, 2015/11/03 23:54:29]

Done.

 //   Arg2: Arguments descriptor array.
 
 //   Returns: target function to call.
 DEFINE_RUNTIME_ENTRY(MegamorphicCacheMissHandler, 3) {
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
+  const Object& ic_data_or_cache = Object::Handle(arguments.ArgAt(1));
   const Array& descriptor = Array::CheckedHandle(arguments.ArgAt(2));
-  const String& name = String::Handle(ic_data.target_name());
-  const MegamorphicCache& cache = MegamorphicCache::Handle(
-      MegamorphicCacheTable::Lookup(isolate, name, descriptor));
+  String& name = String::Handle();

[srdjan, 2015/11/03 22:30:49]

zone is already defined here, please use it for handles.

[rmacnak, 2015/11/03 23:54:29]

Done

+  if (ic_data_or_cache.IsICData()) {
+    name = ICData::Cast(ic_data_or_cache).target_name();
+  } else {
+    ASSERT(ic_data_or_cache.IsMegamorphicCache());
+    name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
+  }
   Class& cls = Class::Handle(receiver.clazz());
   ASSERT(!cls.IsNull());
   if (FLAG_trace_ic || FLAG_trace_ic_miss_in_optimized) {
     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()) {
-    target_function = InlineCacheMissHelper(receiver, ic_data);
+    target_function = InlineCacheMissHelper(receiver, descriptor, name);
   }
   if (target_function.IsNull()) {
     ASSERT(!FLAG_lazy_dispatchers);
+    // TODO(rmacnak): Consider inserting null into the cache.
     arguments.SetReturn(target_function);
     return;
   }
-  // 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);
+
+  if (ic_data_or_cache.IsICData()) {
+    const ICData& ic_data = ICData::Cast(ic_data_or_cache);
+    if (ic_data.NumberOfChecks() == FLAG_max_polymorphic_checks) {

[srdjan, 2015/11/03 22:30:49]

Use '>=', it is more reliable than '=='

[rmacnak, 2015/11/03 23:54:29]

Done.

+      // Switch
+      const MegamorphicCache& cache = MegamorphicCache::Handle(
+          MegamorphicCacheTable::Lookup(isolate, name, descriptor));
+      DartFrameIterator iterator;
+      StackFrame* miss_function_frame = iterator.NextFrame();
+      ASSERT(miss_function_frame->IsDartFrame());
+      StackFrame* caller_frame = iterator.NextFrame();
+      ASSERT(caller_frame->IsDartFrame());
+      const Code& code = Code::Handle(caller_frame->LookupDartCode());
+      const Code& stub =
+          Code::Handle(StubCode::MegamorphicLookup_entry()->code());
+      CodePatcher::PatchSwitchableCallAt(caller_frame->pc(),
+                                         code, ic_data, cache, stub);
+    } else {
+      ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
+    }
+  } else {
+    const MegamorphicCache& cache = MegamorphicCache::Cast(ic_data_or_cache);
+    // 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);
 }
 
 
 // Invoke appropriate noSuchMethod or closure from getter.
 // Arg0: receiver
 // Arg1: IC data

[srdjan, 2015/11/03 22:30:49]

or cache

[rmacnak, 2015/11/03 23:54:29]

Done.

 // Arg2: arguments descriptor array
 // Arg3: arguments array
 DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethodDispatcher, 4) {
   ASSERT(!FLAG_lazy_dispatchers);
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
-  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
+  const Object& ic_data_or_cache = Object::Handle(arguments.ArgAt(1));
   const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(2));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(3));
-  const String& target_name = String::Handle(ic_data.target_name());
+  String& target_name = String::Handle();
+  if (ic_data_or_cache.IsICData()) {
+    target_name = ICData::Cast(ic_data_or_cache).target_name();
+  } else {
+    ASSERT(ic_data_or_cache.IsMegamorphicCache());
+    target_name = MegamorphicCache::Cast(ic_data_or_cache).target_name();
+  }
 
   Class& cls = Class::Handle(receiver.clazz());
   Function& function = Function::Handle();
 
   // Dart distinguishes getters and regular methods and allows their calls
   // to mix with conversions, and its selectors are independent of arity. So do
   // a zigzagged lookup to see if this call failed because of an arity mismatch,
   // need for conversion, or there really is no such method.
 
 #define NO_SUCH_METHOD()                                                       \
@@ skipping 772 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart