Adds the possibility of setting a Code object as the callback of a FunctionTemplate.

src/execution.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/execution.h"
 
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/isolate-inl.h"
@@ skipping 122 matching lines @@
   // directly to a global object.
   if (receiver->IsJSGlobalObject()) {
     receiver =
         handle(Handle<JSGlobalObject>::cast(receiver)->global_proxy(), isolate);
   }
 
   // api callbacks can be called directly.
   if (callable->IsJSFunction() &&
       Handle<JSFunction>::cast(callable)->shared()->IsApiFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
-    SaveContext save(isolate);
-    isolate->set_context(function->context());
-    // Do proper receiver conversion for non-strict mode api functions.
-    if (!receiver->IsJSReceiver() &&
-        is_sloppy(function->shared()->language_mode())) {
-      if (receiver->IsUndefined() || receiver->IsNull()) {
-        receiver = handle(function->global_proxy(), isolate);
+    Object* call_code = function->shared()->get_api_func_data()->call_code();
+    if (call_code->IsCallHandlerInfo() &&
+        !CallHandlerInfo::cast(call_code)->callback()->IsCode()) {

[Toon Verwaest, 2015/11/13 09:55:49]

Don't we want the ability to stay in C++ if we are there? Hence, shouldn't "fast
api callbacks" that can stay in JS when we are there, also have the C++ fallback
in case we call from C++? That would obviate this change.

[epertoso, 2015/11/13 19:06:10]

Well, not necessarily. The fast callback, on the current state of things, is
executed without leaving javascript, but it might bail-out for any reason (e.g.
in the case of Blink, V8 wrappers for DOM nodes are created lazily the first
time they're accessed. The fast path checks that a wrapper is present, if not it
will bailout to C++).

You're correct in saying that in this case we might have up to two more
transitions (from C++ to JS and in the worse case scenario to C++ again).

Daniel, what do you think?

[Benedikt Meurer, 2015/11/16 04:43:55]

I think there should always be a C++ backup implementation, which is complete;
hence we should just leave the "fast C++ path" here. It's definitely cheaper
than going through JavaScript land first.

[epertoso, 2015/11/17 10:32:43]

Done. Added a new field to CallHandlerInfo, as discussed offline.

+      SaveContext save(isolate);
+      isolate->set_context(function->context());
+      // Do proper receiver conversion for non-strict mode api functions.
+      if (!receiver->IsJSReceiver() &&
+          is_sloppy(function->shared()->language_mode())) {
+        if (receiver->IsUndefined() || receiver->IsNull()) {
+          receiver = handle(function->global_proxy(), isolate);
+        } else {
+          ASSIGN_RETURN_ON_EXCEPTION(isolate, receiver,
+                                     Execution::ToObject(isolate, receiver),
+                                     Object);
+        }
+      }
+      DCHECK(function->context()->global_object()->IsJSGlobalObject());
+      auto value = Builtins::InvokeApiFunction(function, receiver, argc, argv);
+      bool has_exception = value.is_null();
+      DCHECK(has_exception == isolate->has_pending_exception());
+      if (has_exception) {
+        isolate->ReportPendingMessages();
+        return MaybeHandle<Object>();
       } else {
-        ASSIGN_RETURN_ON_EXCEPTION(
-            isolate, receiver, Execution::ToObject(isolate, receiver), Object);
+        isolate->clear_pending_message();
       }
+      return value;
     }
-    DCHECK(function->context()->global_object()->IsJSGlobalObject());
-    auto value = Builtins::InvokeApiFunction(function, receiver, argc, argv);
-    bool has_exception = value.is_null();
-    DCHECK(has_exception == isolate->has_pending_exception());
-    if (has_exception) {
-      isolate->ReportPendingMessages();
-      return MaybeHandle<Object>();
-    } else {
-      isolate->clear_pending_message();
-    }
-    return value;
   }
   return Invoke(isolate, false, callable, receiver, argc, argv,
                 isolate->factory()->undefined_value());
 }
 
 
 // static
 MaybeHandle<Object> Execution::New(Handle<JSFunction> constructor, int argc,
                                    Handle<Object> argv[]) {
   return New(constructor->GetIsolate(), constructor, constructor, argc, argv);
@@ skipping 349 matching lines @@
 
   isolate_->counters()->stack_interrupts()->Increment();
   isolate_->counters()->runtime_profiler_ticks()->Increment();
   isolate_->runtime_profiler()->OptimizeNow();
 
   return isolate_->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8