[promisehook] Add is_promisehook_enabled

This will be used in CSA to check if any promisehook is set.

-- Adds a is_promisehook_enabled_ field to the isolate and helper methods.
-- Adds this field to the ExternalReference table.
-- Adds a helper method to access this from CSA

Note -- this patch doesn't actually add the ability to attach the hook
yet.

BUG=v8:4643

Review-Url: https://codereview.chromium.org/2566483002
Cr-Commit-Position: refs/heads/master@{#41607}

src/assembler.cc

@@ -1566,6 +1566,11 @@ ExternalReference ExternalReference::is_tail_call_elimination_enabled_address(
   return ExternalReference(isolate->is_tail_call_elimination_enabled_address());
 }
 
+ExternalReference ExternalReference::is_promisehook_enabled_address(
+    Isolate* isolate) {
+  return ExternalReference(isolate->is_promisehook_enabled_address());
+}
+
 ExternalReference ExternalReference::debug_is_active_address(
     Isolate* isolate) {
   return ExternalReference(isolate->debug()->is_active_address());

src/assembler.h

@@ -1041,6 +1041,8 @@ class ExternalReference BASE_EMBEDDED {
   static ExternalReference invoke_function_callback(Isolate* isolate);
   static ExternalReference invoke_accessor_getter_callback(Isolate* isolate);
 
+  static ExternalReference is_promisehook_enabled_address(Isolate* isolate);
+
   V8_EXPORT_PRIVATE static ExternalReference runtime_function_table_address(
       Isolate* isolate);
 

src/code-stub-assembler.cc

@@ -8237,5 +8237,13 @@ Node* CodeStubAssembler::IsDebugActive() {
   return WordNotEqual(is_debug_active, Int32Constant(0));
 }
 
+Node* CodeStubAssembler::IsPromiseHookEnabled() {
+  Node* const is_promisehook_enabled =
+      Load(MachineType::Uint8(),
+           ExternalConstant(
+               ExternalReference::is_promisehook_enabled_address(isolate())));
+  return WordNotEqual(is_promisehook_enabled, Int32Constant(0));
+}
+
 }  // namespace internal
 }  // namespace v8

src/code-stub-assembler.h

@@ -1050,6 +1050,9 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
   Node* ElementOffsetFromIndex(Node* index, ElementsKind kind,
                                ParameterMode mode, int base_size = 0);
 
+  // Promise helpers
+  Node* IsPromiseHookEnabled();
+
  protected:
   void DescriptorLookupLinear(Node* unique_name, Node* descriptors, Node* nof,
                               Label* if_found, Variable* var_name_index,

src/external-reference-table.cc

@@ -249,6 +249,8 @@ void ExternalReferenceTable::AddReferences(Isolate* isolate) {
       "double_absolute_constant");
   Add(ExternalReference::address_of_double_neg_constant().address(),
       "double_negate_constant");
+  Add(ExternalReference::is_promisehook_enabled_address(isolate).address(),
+      "Isolate::is_promisehook_enabled_address()");
 
   // Debug addresses
   Add(ExternalReference::debug_after_break_target_address(isolate).address(),

src/isolate.cc

@@ -2129,6 +2129,7 @@ Isolate::Isolate(bool enable_serializer)
       serializer_enabled_(enable_serializer),
       has_fatal_error_(false),
       initialized_from_snapshot_(false),
+      is_promisehook_enabled_(false),
       is_tail_call_elimination_enabled_(true),
       is_isolate_in_background_(false),
       cpu_profiler_(NULL),
@@ -3140,6 +3141,9 @@ void Isolate::FireCallCompletedCallback() {
   }
 }
 
+void Isolate::EnablePromiseHook() { is_promisehook_enabled_ = true; }
+
+void Isolate::DisablePromiseHook() { is_promisehook_enabled_ = false; }
 
 void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
   promise_reject_callback_ = callback;

src/isolate.h

@@ -1123,6 +1123,13 @@ class Isolate {
   int GetNextUniqueSharedFunctionInfoId() { return next_unique_sfi_id_++; }
 #endif
 
+  Address is_promisehook_enabled_address() {
+    return reinterpret_cast<Address>(&is_promisehook_enabled_);
+  }
+  bool IsPromiseHookEnabled() { return is_promisehook_enabled_; }
+  void EnablePromiseHook();
+  void DisablePromiseHook();
+
   // Support for dynamically disabling tail call elimination.
   Address is_tail_call_elimination_enabled_address() {
     return reinterpret_cast<Address>(&is_tail_call_elimination_enabled_);
@@ -1363,6 +1370,9 @@ class Isolate {
   // True if this isolate was initialized from a snapshot.
   bool initialized_from_snapshot_;
 
+  // True if PromiseHook feature is enabled.
+  bool is_promisehook_enabled_;
+
   // True if ES2015 tail call elimination feature is enabled.
   bool is_tail_call_elimination_enabled_;
 

test/cctest/test-code-stub-assembler.cc

@@ -1972,5 +1972,32 @@ TEST(CodeStubAssemblerGraphsCorrectness) {
   v8_isolate->Dispose();
 }
 
+TEST(IsPromiseHookEnabled) {
+  Isolate* isolate(CcTest::InitIsolateOnce());
+
+  const int kNumParams = 1;
+  CodeAssemblerTester data(isolate, kNumParams);
+  CodeStubAssembler m(data.state());
+
+  m.Return(m.SelectBooleanConstant(m.IsPromiseHookEnabled()));
+
+  Handle<Code> code = data.GenerateCode();
+  CHECK(!code.is_null());
+
+  FunctionTester ft(code, kNumParams);
+  CHECK_EQ(false, isolate->IsPromiseHookEnabled());
+  Handle<Object> result =
+      ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
+  CHECK_EQ(isolate->heap()->false_value(), *result);
+
+  isolate->EnablePromiseHook();
+  result = ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
+  CHECK_EQ(isolate->heap()->true_value(), *result);
+
+  isolate->DisablePromiseHook();
+  result = ft.Call(isolate->factory()->undefined_value()).ToHandleChecked();
+  CHECK_EQ(isolate->heap()->false_value(), *result);
+}
+
 }  // namespace internal
 }  // namespace v8