[promisehook] Fire init hook for promise subclass

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-promise.h"
 #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 594 matching lines @@
 
   Node* const executor_map = LoadMap(executor);
   GotoUnless(IsCallableMap(executor_map), &if_notcallable);
 
   Node* const native_context = LoadNativeContext(context);
   Node* const promise_fun =
       LoadContextElement(native_context, Context::PROMISE_FUNCTION_INDEX);
   Node* const is_debug_active = IsDebugActive();
   Label if_targetisnotmodified(this),
       if_targetismodified(this, Label::kDeferred), run_executor(this),
-      debug_push(this, Label::kDeferred), init(this);
+      debug_push(this), init(this);
 
   Branch(WordEqual(promise_fun, new_target), &if_targetisnotmodified,
          &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);
     Goto(&init);
   }
 
   Bind(&init);
   {
     PromiseInit(var_result.value());
-    Branch(is_debug_active, &debug_push, &run_executor);
+    GotoUnless(IsPromiseHookEnabled(), &debug_push);
+    CallRuntime(Runtime::kPromiseHookInit, context, var_result.value(),
+                UndefinedConstant());
+    Goto(&debug_push);
   }
 
   Bind(&debug_push);
   {
+    GotoUnless(is_debug_active, &run_executor);
     CallRuntime(Runtime::kDebugPushPromise, context, var_result.value());
     Goto(&run_executor);
   }
 
   Bind(&run_executor);
   {
     Label out(this), if_rejectpromise(this), debug_pop(this, Label::kDeferred);
 
     Node *resolve, *reject;
     std::tie(resolve, reject) = CreatePromiseResolvingFunctions(
@@ skipping 324 matching lines @@
     CallRuntime(Runtime::kDebugPopPromise, context);
     Goto(&out);
 
     Bind(&out);
     Return(UndefinedConstant());
   }
 }
 
 }  // namespace internal
 }  // namespace v8