Port "Add flag to disable lazy compilation of invocation dispatchers."

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 51 matching lines @@
 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");
 DEFINE_FLAG(charp, deoptimize_filter, NULL,
             "Deoptimize in named function on stack overflow checks");
+DEFINE_FLAG(bool, lazy_dispatchers, true, "Lazily generate dispatchers");
 
 #ifdef DEBUG
 DEFINE_FLAG(charp, gc_at_instance_allocation, NULL,
             "Perform a GC before allocation of instances of "
             "the specified class");
 #endif
 
 DEFINE_RUNTIME_ENTRY(TraceFunctionEntry, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   const String& function_name = String::Handle(function.name());
@@ skipping 687 matching lines @@
 
   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)) {
+    if (!FLAG_lazy_dispatchers) {
+      return result.raw();  // Return null.
+    }
     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(),
           receiver.GetClassId(),
@@ skipping 15 matching lines @@
   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);
   }
-  ASSERT(!target_function.IsNull());
+  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());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(args[i]->GetClassId());
     }
     ic_data.AddCheck(class_ids, target_function);
   }
@@ skipping 180 matching lines @@
   }
 
   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);
   }
-
-  ASSERT(!target_function.IsNull());
+  if (target_function.IsNull()) {
+    ASSERT(!FLAG_lazy_dispatchers);
+    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);
   arguments.SetReturn(target_function);
 }
 
 
+// Invoke appropriate noSuchMethod or closure from getter.
+// Arg0: receiver
+// Arg1: IC data
+// 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 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());
+  // Handle noSuchMethod invocation.
+  const Object& result = Object::Handle(
+      DartEntry::InvokeNoSuchMethod(receiver,
+                                    target_name,
+                                    orig_arguments,
+                                    orig_arguments_desc));
+  CheckResultError(result);
+  arguments.SetReturn(result);
+}
+
+
+
 // Invoke appropriate noSuchMethod function.
 // Arg0: receiver (closure object)
 // Arg1: arguments descriptor array.
 // Arg2: arguments array.
 DEFINE_RUNTIME_ENTRY(InvokeClosureNoSuchMethod, 3) {
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Array& orig_arguments_desc = Array::CheckedHandle(arguments.ArgAt(1));
   const Array& orig_arguments = Array::CheckedHandle(arguments.ArgAt(2));
 
   // For closure the function name is always 'call'. Replace it with the
@@ skipping 649 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