[promisehook] Implement PromiseHook

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/promise-utils.h"
 
@@ skipping 353 matching lines @@
                                                       Node* result,
                                                       Label* out) {
   Isolate* isolate = this->isolate();
 
   Variable var_reason(this, MachineRepresentation::kTagged),
       var_then(this, MachineRepresentation::kTagged);
 
   Label do_enqueue(this), fulfill(this), if_cycle(this, Label::kDeferred),
       if_rejectpromise(this, Label::kDeferred);
 
+  Label cycle_check(this);
+  GotoUnless(IsPromiseHookEnabled(), &cycle_check);
+  CallRuntime(Runtime::kPromiseHookResolve, context, promise);
+  Goto(&cycle_check);
+
+  Bind(&cycle_check);
   // 6. If SameValue(resolution, promise) is true, then
   GotoIf(SameValue(promise, result, context), &if_cycle);
 
   // 7. If Type(resolution) is not Object, then
   GotoIf(TaggedIsSmi(result), &fulfill);
   GotoUnless(IsJSReceiver(result), &fulfill);
 
   Label if_nativepromise(this), if_notnativepromise(this, Label::kDeferred);
   BranchIfFastPath(context, result, &if_nativepromise, &if_notnativepromise);
 
@@ skipping 200 matching lines @@
          &if_targetismodified);
 
   Variable var_result(this, MachineRepresentation::kTagged),
       var_reject_call(this, MachineRepresentation::kTagged),
       var_reason(this, MachineRepresentation::kTagged);
 
   Bind(&if_targetisnotmodified);
   {
     Node* const instance = AllocateJSPromise(context);
     var_result.Bind(instance);
+    GotoUnless(IsPromiseHookEnabled(), &init);
+    CallRuntime(Runtime::kPromiseHookInit, context, instance,
+                UndefinedConstant());
     Goto(&init);
   }
 
   Bind(&if_targetismodified);
   {
     Callable fast_new_object_stub = CodeFactory::FastNewObject(isolate);
     Node* const instance =
         CallStub(fast_new_object_stub, context, promise_fun, new_target);
 
     var_result.Bind(instance);
@@ skipping 60 matching lines @@
   Bind(&if_notcallable);
   {
     Node* const message_id =
         SmiConstant(MessageTemplate::kResolverNotAFunction);
     CallRuntime(Runtime::kThrowTypeError, context, message_id, executor);
     Return(UndefinedConstant());  // Never reached.
   }
 }
 
 TF_BUILTIN(PromiseInternalConstructor, PromiseBuiltinsAssembler) {
-  Node* const context = Parameter(3);
+  Node* const parent = Parameter(1);
+  Node* const context = Parameter(4);
   Node* const instance = AllocateJSPromise(context);
   PromiseInit(instance);
+
+  Label out(this);
+  GotoUnless(IsPromiseHookEnabled(), &out);
+  CallRuntime(Runtime::kPromiseHookInit, context, instance, parent);
+  Goto(&out);
+  Bind(&out);
+
   Return(instance);
 }
 
 TF_BUILTIN(PromiseCreateAndSet, PromiseBuiltinsAssembler) {
   Node* const status = Parameter(1);
   Node* const result = Parameter(2);
   Node* const context = Parameter(5);
 
   Node* const instance = AllocateJSPromise(context);
   PromiseSet(instance, status, result);
+
+  Label out(this);
+  GotoUnless(IsPromiseHookEnabled(), &out);
+  CallRuntime(Runtime::kPromiseHookInit, context, instance,
+              UndefinedConstant());
+  Goto(&out);
+  Bind(&out);
   Return(instance);
 }
 
 TF_BUILTIN(IsPromise, PromiseBuiltinsAssembler) {
   Node* const maybe_promise = Parameter(1);
   Label if_notpromise(this, Label::kDeferred);
 
   GotoIf(TaggedIsSmi(maybe_promise), &if_notpromise);
 
   Node* const result =
@@ skipping 48 matching lines @@
 
   // TODO(gsathya): Remove deferred object and move
   // NewPromiseCapabability functions to TF.
   Bind(&fast_promise_capability);
   {
     // TODO(gsathya): Move this to TF.
     Node* const promise_internal_capability = LoadContextElement(
         native_context, Context::INTERNAL_PROMISE_CAPABILITY_INDEX);
     Node* const capability =
         CallJS(call_callable, context, promise_internal_capability,
-               UndefinedConstant());
+               UndefinedConstant(), promise);
     var_deferred.Bind(capability);
     Goto(&perform_promise_then);
   }
 
   Bind(&promise_capability);
   {
     // TODO(gsathya): Move this to TF.
     Node* const new_promise_capability = LoadContextElement(
         native_context, Context::NEW_PROMISE_CAPABILITY_INDEX);
     Node* const capability =
@@ skipping 76 matching lines @@
   }
 
   Bind(&if_customhandler);
   {
     CallJS(call_callable, context, on_reject, UndefinedConstant(), exception);
     Return(UndefinedConstant());
   }
 }
 
 TF_BUILTIN(PromiseHandle, PromiseBuiltinsAssembler) {
+  Node* const promise = Parameter(1);
   Node* const value = Parameter(2);
   Node* const handler = Parameter(3);
   Node* const deferred = Parameter(4);
   Node* const context = Parameter(7);
   Isolate* isolate = this->isolate();
 
   // Get promise from deferred
   // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
   Callable getproperty_callable = CodeFactory::GetProperty(isolate);
   Node* const key = HeapConstant(isolate->factory()->promise_string());
   Node* const deferred_promise =
       CallStub(getproperty_callable, context, deferred, key);
 
   Variable var_reason(this, MachineRepresentation::kTagged);
 
   Node* const is_debug_active = IsDebugActive();
-  Label run_handler(this), if_rejectpromise(this),
-      debug_push(this, Label::kDeferred), debug_pop(this, Label::kDeferred);
-  Branch(is_debug_active, &debug_push, &run_handler);
+  Label run_handler(this), if_rejectpromise(this), promisehook_before(this),
+      promisehook_after(this), debug_pop(this);
 
-  Bind(&debug_push);
+  GotoUnless(is_debug_active, &promisehook_before);
+  CallRuntime(Runtime::kDebugPushPromise, context, deferred_promise);
+  Goto(&promisehook_before);
+
+  Bind(&promisehook_before);
   {
-    CallRuntime(Runtime::kDebugPushPromise, context, deferred_promise);
+    GotoUnless(IsPromiseHookEnabled(), &run_handler);
+    CallRuntime(Runtime::kPromiseHookBefore, context, promise);
     Goto(&run_handler);
   }
 
   Bind(&run_handler);
   {
     Callable call_callable = CodeFactory::Call(isolate);
 
     Node* const result =
         CallJS(call_callable, context, handler, UndefinedConstant(), value);
 
     GotoIfException(result, &if_rejectpromise, &var_reason);
 
     // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
     Node* const key = HeapConstant(isolate->factory()->resolve_string());
     Node* const on_resolve =
         CallStub(getproperty_callable, context, deferred, key);
 
     Label if_internalhandler(this), if_customhandler(this, Label::kDeferred);
     Branch(IsUndefined(on_resolve), &if_internalhandler, &if_customhandler);
 
     Bind(&if_internalhandler);
-    InternalResolvePromise(context, deferred_promise, result, &debug_pop);
+    InternalResolvePromise(context, deferred_promise, result,
+                           &promisehook_after);
 
     Bind(&if_customhandler);
     {
       Node* const maybe_exception = CallJS(call_callable, context, on_resolve,
                                            UndefinedConstant(), result);
       GotoIfException(maybe_exception, &if_rejectpromise, &var_reason);
-      Goto(&debug_pop);
+      Goto(&promisehook_after);
     }
   }
 
   Bind(&if_rejectpromise);
   {
     // TODO(gsathya): Remove this lookup by getting rid of the deferred object.
     Node* const key = HeapConstant(isolate->factory()->reject_string());
     Node* const on_reject =
         CallStub(getproperty_callable, context, deferred, key);
 
     Callable promise_handle_reject = CodeFactory::PromiseHandleReject(isolate);
     CallStub(promise_handle_reject, context, deferred_promise, on_reject,
              var_reason.value());
+    Goto(&promisehook_after);
+  }
+
+  Bind(&promisehook_after);
+  {
+    GotoUnless(IsPromiseHookEnabled(), &debug_pop);
+    CallRuntime(Runtime::kPromiseHookAfter, context, promise);
     Goto(&debug_pop);
   }
 
   Bind(&debug_pop);
   {
     Label out(this);
 
     GotoUnless(is_debug_active, &out);
     CallRuntime(Runtime::kDebugPopPromise, context);
     Goto(&out);
 
     Bind(&out);
     Return(UndefinedConstant());
   }
 }
 
 }  // namespace internal
 }  // namespace v8