v8-isolate.h

Go to the documentation of this file.

// Copyright 2021 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.
 
#ifndef INCLUDE_V8_ISOLATE_H_
#define INCLUDE_V8_ISOLATE_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include <memory>
#include <utility>
 
#include "cppgc/common.h"
#include "v8-array-buffer.h"       // NOLINT(build/include_directory)
#include "v8-callbacks.h"          // NOLINT(build/include_directory)
#include "v8-data.h"               // NOLINT(build/include_directory)
#include "v8-debug.h"              // NOLINT(build/include_directory)
#include "v8-embedder-heap.h"      // NOLINT(build/include_directory)
#include "v8-function-callback.h"  // NOLINT(build/include_directory)
#include "v8-internal.h"           // NOLINT(build/include_directory)
#include "v8-local-handle.h"       // NOLINT(build/include_directory)
#include "v8-microtask.h"          // NOLINT(build/include_directory)
#include "v8-persistent-handle.h"  // NOLINT(build/include_directory)
#include "v8-primitive.h"          // NOLINT(build/include_directory)
#include "v8-statistics.h"         // NOLINT(build/include_directory)
#include "v8-unwinder.h"           // NOLINT(build/include_directory)
#include "v8config.h"              // NOLINT(build/include_directory)
 
namespace v8 {
 
class CppHeap;
class HeapProfiler;
class MicrotaskQueue;
class StartupData;
class ScriptOrModule;
class SharedArrayBuffer;
 
namespace internal {
class MicrotaskQueue;
class ThreadLocalTop;
}  // namespace internal
 
namespace metrics {
class Recorder;
}  // namespace metrics
 
class V8_EXPORT ResourceConstraints {
 public:
  void ConfigureDefaultsFromHeapSize(size_t initial_heap_size_in_bytes,
                                     size_t maximum_heap_size_in_bytes);
 
  void ConfigureDefaults(uint64_t physical_memory,
                         uint64_t virtual_memory_limit);
 
  uint32_t* stack_limit() const { return stack_limit_; }
  void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
 
  size_t code_range_size_in_bytes() const { return code_range_size_; }
  void set_code_range_size_in_bytes(size_t limit) { code_range_size_ = limit; }
 
  size_t max_old_generation_size_in_bytes() const {
    return max_old_generation_size_;
  }
  void set_max_old_generation_size_in_bytes(size_t limit) {
    max_old_generation_size_ = limit;
  }
 
  size_t max_young_generation_size_in_bytes() const {
    return max_young_generation_size_;
  }
  void set_max_young_generation_size_in_bytes(size_t limit) {
    max_young_generation_size_ = limit;
  }
 
  size_t initial_old_generation_size_in_bytes() const {
    return initial_old_generation_size_;
  }
  void set_initial_old_generation_size_in_bytes(size_t initial_size) {
    initial_old_generation_size_ = initial_size;
  }
 
  size_t initial_young_generation_size_in_bytes() const {
    return initial_young_generation_size_;
  }
  void set_initial_young_generation_size_in_bytes(size_t initial_size) {
    initial_young_generation_size_ = initial_size;
  }
 
 private:
  static constexpr size_t kMB = 1048576u;
  size_t code_range_size_ = 0;
  size_t max_old_generation_size_ = 0;
  size_t max_young_generation_size_ = 0;
  size_t initial_old_generation_size_ = 0;
  size_t initial_young_generation_size_ = 0;
  uint32_t* stack_limit_ = nullptr;
};
 
enum RAILMode : unsigned {
  // Response performance mode: In this mode very low virtual machine latency
  // is provided. V8 will try to avoid JavaScript execution interruptions.
  // Throughput may be throttled.
  PERFORMANCE_RESPONSE,
  // Animation performance mode: In this mode low virtual machine latency is
  // provided. V8 will try to avoid as many JavaScript execution interruptions
  // as possible. Throughput may be throttled. This is the default mode.
  PERFORMANCE_ANIMATION,
  // Idle performance mode: The embedder is idle. V8 can complete deferred work
  // in this mode.
  PERFORMANCE_IDLE,
  // Load performance mode: In this mode high throughput is provided. V8 may
  // turn off latency optimizations.
  PERFORMANCE_LOAD
};
 
enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
using StackState = cppgc::EmbedderStackState;
 
class V8_EXPORT Isolate {
 public:
  struct V8_EXPORT CreateParams {
    CreateParams();
    ~CreateParams();
 
    ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(CreateParams)
 
    
    JitCodeEventHandler code_event_handler = nullptr;
 
    ResourceConstraints constraints;
 
    const StartupData* snapshot_blob = nullptr;
 
    CounterLookupCallback counter_lookup_callback = nullptr;
 
    CreateHistogramCallback create_histogram_callback = nullptr;
    AddHistogramSampleCallback add_histogram_sample_callback = nullptr;
 
    ArrayBuffer::Allocator* array_buffer_allocator = nullptr;
    std::shared_ptr<ArrayBuffer::Allocator> array_buffer_allocator_shared;
 
    const intptr_t* external_references = nullptr;
 
    bool allow_atomics_wait = true;
 
    bool only_terminate_in_safe_scope = false;
 
    int embedder_wrapper_type_index = -1;
    int embedder_wrapper_object_index = -1;
 
    FatalErrorCallback fatal_error_callback = nullptr;
    OOMErrorCallback oom_error_callback = nullptr;
  };
 
  class V8_EXPORT V8_NODISCARD Scope {
   public:
    explicit Scope(Isolate* isolate) : v8_isolate_(isolate) {
      v8_isolate_->Enter();
    }
 
    ~Scope() { v8_isolate_->Exit(); }
 
    // Prevent copying of Scope objects.
    Scope(const Scope&) = delete;
    Scope& operator=(const Scope&) = delete;
 
   private:
    Isolate* const v8_isolate_;
  };
 
  class V8_EXPORT V8_NODISCARD DisallowJavascriptExecutionScope {
   public:
    enum OnFailure { CRASH_ON_FAILURE, THROW_ON_FAILURE, DUMP_ON_FAILURE };
 
    DisallowJavascriptExecutionScope(Isolate* isolate, OnFailure on_failure);
    ~DisallowJavascriptExecutionScope();
 
    // Prevent copying of Scope objects.
    DisallowJavascriptExecutionScope(const DisallowJavascriptExecutionScope&) =
        delete;
    DisallowJavascriptExecutionScope& operator=(
        const DisallowJavascriptExecutionScope&) = delete;
 
   private:
    v8::Isolate* const v8_isolate_;
    const OnFailure on_failure_;
    bool was_execution_allowed_;
  };
 
  class V8_EXPORT V8_NODISCARD AllowJavascriptExecutionScope {
   public:
    explicit AllowJavascriptExecutionScope(Isolate* isolate);
    ~AllowJavascriptExecutionScope();
 
    // Prevent copying of Scope objects.
    AllowJavascriptExecutionScope(const AllowJavascriptExecutionScope&) =
        delete;
    AllowJavascriptExecutionScope& operator=(
        const AllowJavascriptExecutionScope&) = delete;
 
   private:
    Isolate* const v8_isolate_;
    bool was_execution_allowed_assert_;
    bool was_execution_allowed_throws_;
    bool was_execution_allowed_dump_;
  };
 
  class V8_EXPORT V8_NODISCARD SuppressMicrotaskExecutionScope {
   public:
    explicit SuppressMicrotaskExecutionScope(
        Isolate* isolate, MicrotaskQueue* microtask_queue = nullptr);
    ~SuppressMicrotaskExecutionScope();
 
    // Prevent copying of Scope objects.
    SuppressMicrotaskExecutionScope(const SuppressMicrotaskExecutionScope&) =
        delete;
    SuppressMicrotaskExecutionScope& operator=(
        const SuppressMicrotaskExecutionScope&) = delete;
 
   private:
    internal::Isolate* const i_isolate_;
    internal::MicrotaskQueue* const microtask_queue_;
    internal::Address previous_stack_height_;
 
    friend class internal::ThreadLocalTop;
  };
 
  class V8_EXPORT V8_NODISCARD SafeForTerminationScope {
   public:
    explicit SafeForTerminationScope(v8::Isolate* v8_isolate);
    ~SafeForTerminationScope();
 
    // Prevent copying of Scope objects.
    SafeForTerminationScope(const SafeForTerminationScope&) = delete;
    SafeForTerminationScope& operator=(const SafeForTerminationScope&) = delete;
 
   private:
    internal::Isolate* i_isolate_;
    bool prev_value_;
  };
 
  enum GarbageCollectionType {
    kFullGarbageCollection,
    kMinorGarbageCollection
  };
 
  enum UseCounterFeature {
    kUseAsm = 0,
    kBreakIterator = 1,
    kLegacyConst = 2,
    kMarkDequeOverflow = 3,
    kStoreBufferOverflow = 4,
    kSlotsBufferOverflow = 5,
    kObjectObserve = 6,
    kForcedGC = 7,
    kSloppyMode = 8,
    kStrictMode = 9,
    kStrongMode = 10,
    kRegExpPrototypeStickyGetter = 11,
    kRegExpPrototypeToString = 12,
    kRegExpPrototypeUnicodeGetter = 13,
    kIntlV8Parse = 14,
    kIntlPattern = 15,
    kIntlResolved = 16,
    kPromiseChain = 17,
    kPromiseAccept = 18,
    kPromiseDefer = 19,
    kHtmlCommentInExternalScript = 20,
    kHtmlComment = 21,
    kSloppyModeBlockScopedFunctionRedefinition = 22,
    kForInInitializer = 23,
    kArrayProtectorDirtied = 24,
    kArraySpeciesModified = 25,
    kArrayPrototypeConstructorModified = 26,
    kArrayInstanceProtoModified = 27,
    kArrayInstanceConstructorModified = 28,
    kLegacyFunctionDeclaration = 29,
    kRegExpPrototypeSourceGetter = 30,   // Unused.
    kRegExpPrototypeOldFlagGetter = 31,  // Unused.
    kDecimalWithLeadingZeroInStrictMode = 32,
    kLegacyDateParser = 33,
    kDefineGetterOrSetterWouldThrow = 34,
    kFunctionConstructorReturnedUndefined = 35,
    kAssigmentExpressionLHSIsCallInSloppy = 36,
    kAssigmentExpressionLHSIsCallInStrict = 37,
    kPromiseConstructorReturnedUndefined = 38,
    kConstructorNonUndefinedPrimitiveReturn = 39,
    kLabeledExpressionStatement = 40,
    kLineOrParagraphSeparatorAsLineTerminator = 41,
    kIndexAccessor = 42,
    kErrorCaptureStackTrace = 43,
    kErrorPrepareStackTrace = 44,
    kErrorStackTraceLimit = 45,
    kWebAssemblyInstantiation = 46,
    kDeoptimizerDisableSpeculation = 47,
    kArrayPrototypeSortJSArrayModifiedPrototype = 48,
    kFunctionTokenOffsetTooLongForToString = 49,
    kWasmSharedMemory = 50,
    kWasmThreadOpcodes = 51,
    kAtomicsNotify = 52,  // Unused.
    kAtomicsWake = 53,    // Unused.
    kCollator = 54,
    kNumberFormat = 55,
    kDateTimeFormat = 56,
    kPluralRules = 57,
    kRelativeTimeFormat = 58,
    kLocale = 59,
    kListFormat = 60,
    kSegmenter = 61,
    kStringLocaleCompare = 62,
    kStringToLocaleUpperCase = 63,
    kStringToLocaleLowerCase = 64,
    kNumberToLocaleString = 65,
    kDateToLocaleString = 66,
    kDateToLocaleDateString = 67,
    kDateToLocaleTimeString = 68,
    kAttemptOverrideReadOnlyOnPrototypeSloppy = 69,
    kAttemptOverrideReadOnlyOnPrototypeStrict = 70,
    kOptimizedFunctionWithOneShotBytecode = 71,  // Unused.
    kRegExpMatchIsTrueishOnNonJSRegExp = 72,
    kRegExpMatchIsFalseishOnJSRegExp = 73,
    kDateGetTimezoneOffset = 74,  // Unused.
    kStringNormalize = 75,
    kCallSiteAPIGetFunctionSloppyCall = 76,
    kCallSiteAPIGetThisSloppyCall = 77,
    kRegExpMatchAllWithNonGlobalRegExp = 78,
    kRegExpExecCalledOnSlowRegExp = 79,
    kRegExpReplaceCalledOnSlowRegExp = 80,
    kDisplayNames = 81,
    kSharedArrayBufferConstructed = 82,
    kArrayPrototypeHasElements = 83,
    kObjectPrototypeHasElements = 84,
    kNumberFormatStyleUnit = 85,
    kDateTimeFormatRange = 86,
    kDateTimeFormatDateTimeStyle = 87,
    kBreakIteratorTypeWord = 88,
    kBreakIteratorTypeLine = 89,
    kInvalidatedArrayBufferDetachingProtector = 90,
    kInvalidatedArrayConstructorProtector = 91,
    kInvalidatedArrayIteratorLookupChainProtector = 92,
    kInvalidatedArraySpeciesLookupChainProtector = 93,
    kInvalidatedIsConcatSpreadableLookupChainProtector = 94,
    kInvalidatedMapIteratorLookupChainProtector = 95,
    kInvalidatedNoElementsProtector = 96,
    kInvalidatedPromiseHookProtector = 97,
    kInvalidatedPromiseResolveLookupChainProtector = 98,
    kInvalidatedPromiseSpeciesLookupChainProtector = 99,
    kInvalidatedPromiseThenLookupChainProtector = 100,
    kInvalidatedRegExpSpeciesLookupChainProtector = 101,
    kInvalidatedSetIteratorLookupChainProtector = 102,
    kInvalidatedStringIteratorLookupChainProtector = 103,
    kInvalidatedStringLengthOverflowLookupChainProtector = 104,
    kInvalidatedTypedArraySpeciesLookupChainProtector = 105,
    kWasmSimdOpcodes = 106,
    kVarRedeclaredCatchBinding = 107,
    kWasmRefTypes = 108,
    kWasmBulkMemory = 109,  // Unused.
    kWasmMultiValue = 110,
    kWasmExceptionHandling = 111,
    kInvalidatedMegaDOMProtector = 112,
    kFunctionPrototypeArguments = 113,
    kFunctionPrototypeCaller = 114,
    kTurboFanOsrCompileStarted = 115,
    kAsyncStackTaggingCreateTaskCall = 116,
    kDurationFormat = 117,
    kInvalidatedNumberStringPrototypeNoReplaceProtector = 118,
    kRegExpUnicodeSetIncompatibilitiesWithUnicodeMode = 119,  // Unused.
 
    // If you add new values here, you'll also need to update Chromium's:
    // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
    // this list need to be landed first, then changes on the Chromium side.
    kUseCounterFeatureCount  // This enum value must be last.
  };
 
  enum MessageErrorLevel {
    kMessageLog = (1 << 0),
    kMessageDebug = (1 << 1),
    kMessageInfo = (1 << 2),
    kMessageError = (1 << 3),
    kMessageWarning = (1 << 4),
    kMessageAll = kMessageLog | kMessageDebug | kMessageInfo | kMessageError |
                  kMessageWarning,
  };
 
  using UseCounterCallback = void (*)(Isolate* isolate,
                                      UseCounterFeature feature);
 
  static Isolate* Allocate();
 
  static void Initialize(Isolate* isolate, const CreateParams& params);
 
  static Isolate* New(const CreateParams& params);
 
  static Isolate* GetCurrent();
 
  static Isolate* TryGetCurrent();
 
  bool IsCurrent() const;
 
  void ClearKeptObjects();
 
  using AbortOnUncaughtExceptionCallback = bool (*)(Isolate*);
  void SetAbortOnUncaughtExceptionCallback(
      AbortOnUncaughtExceptionCallback callback);
 
  void SetHostImportModuleDynamicallyCallback(
      HostImportModuleDynamicallyCallback callback);
 
  void SetHostInitializeImportMetaObjectCallback(
      HostInitializeImportMetaObjectCallback callback);
 
  void SetHostCreateShadowRealmContextCallback(
      HostCreateShadowRealmContextCallback callback);
 
  void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback);
 
  void MemoryPressureNotification(MemoryPressureLevel level);
 
  void ClearCachesForTesting();
 
  void Enter();
 
  void Exit();
 
  void Dispose();
 
  void DumpAndResetStats();
 
  void DiscardThreadSpecificMetadata();
 
  V8_INLINE void SetData(uint32_t slot, void* data);
 
  V8_INLINE void* GetData(uint32_t slot);
 
  V8_INLINE static uint32_t GetNumberOfDataSlots();
 
  template <class T>
  V8_INLINE MaybeLocal<T> GetDataFromSnapshotOnce(size_t index);
 
  void GetHeapStatistics(HeapStatistics* heap_statistics);
 
  size_t NumberOfHeapSpaces();
 
  bool GetHeapSpaceStatistics(HeapSpaceStatistics* space_statistics,
                              size_t index);
 
  size_t NumberOfTrackedHeapObjectTypes();
 
  bool GetHeapObjectStatisticsAtLastGC(HeapObjectStatistics* object_statistics,
                                       size_t type_index);
 
  bool GetHeapCodeAndMetadataStatistics(HeapCodeStatistics* object_statistics);
 
  bool MeasureMemory(
      std::unique_ptr<MeasureMemoryDelegate> delegate,
      MeasureMemoryExecution execution = MeasureMemoryExecution::kDefault);
 
  void GetStackSample(const RegisterState& state, void** frames,
                      size_t frames_limit, SampleInfo* sample_info);
 
  int64_t AdjustAmountOfExternalAllocatedMemory(int64_t change_in_bytes);
 
  HeapProfiler* GetHeapProfiler();
 
  void SetIdle(bool is_idle);
 
  ArrayBuffer::Allocator* GetArrayBufferAllocator();
 
  bool InContext();
 
  Local<Context> GetCurrentContext();
 
  Local<Context> GetEnteredOrMicrotaskContext();
 
  Local<Context> GetIncumbentContext();
 
  template <int N>
  Local<Value> ThrowError(const char (&message)[N]) {
    return ThrowError(String::NewFromUtf8Literal(this, message));
  }
  Local<Value> ThrowError(Local<String> message);
 
  Local<Value> ThrowException(Local<Value> exception);
 
  using GCCallback = void (*)(Isolate* isolate, GCType type,
                              GCCallbackFlags flags);
  using GCCallbackWithData = void (*)(Isolate* isolate, GCType type,
                                      GCCallbackFlags flags, void* data);
 
  void AddGCPrologueCallback(GCCallbackWithData callback, void* data = nullptr,
                             GCType gc_type_filter = kGCTypeAll);
  void AddGCPrologueCallback(GCCallback callback,
                             GCType gc_type_filter = kGCTypeAll);
 
  void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
  void RemoveGCPrologueCallback(GCCallback callback);
 
  void SetEmbedderRootsHandler(EmbedderRootsHandler* handler);
 
  void AttachCppHeap(CppHeap*);
 
  void DetachCppHeap();
 
  CppHeap* GetCppHeap() const;
 
  enum class AtomicsWaitEvent {
    kStartWait,
    kWokenUp,
    kTimedOut,
    kTerminatedExecution,
    kAPIStopped,
    kNotEqual
  };
 
  class V8_EXPORT AtomicsWaitWakeHandle {
   public:
    void Wake();
  };
 
  using AtomicsWaitCallback = void (*)(AtomicsWaitEvent event,
                                       Local<SharedArrayBuffer> array_buffer,
                                       size_t offset_in_bytes, int64_t value,
                                       double timeout_in_ms,
                                       AtomicsWaitWakeHandle* stop_handle,
                                       void* data);
 
  void SetAtomicsWaitCallback(AtomicsWaitCallback callback, void* data);
 
  void AddGCEpilogueCallback(GCCallbackWithData callback, void* data = nullptr,
                             GCType gc_type_filter = kGCTypeAll);
  void AddGCEpilogueCallback(GCCallback callback,
                             GCType gc_type_filter = kGCTypeAll);
 
  void RemoveGCEpilogueCallback(GCCallbackWithData callback,
                                void* data = nullptr);
  void RemoveGCEpilogueCallback(GCCallback callback);
 
  using GetExternallyAllocatedMemoryInBytesCallback = size_t (*)();
 
  void SetGetExternallyAllocatedMemoryInBytesCallback(
      GetExternallyAllocatedMemoryInBytesCallback callback);
 
  void TerminateExecution();
 
  bool IsExecutionTerminating();
 
  void CancelTerminateExecution();
 
  void RequestInterrupt(InterruptCallback callback, void* data);
 
  bool HasPendingBackgroundTasks();
 
  void RequestGarbageCollectionForTesting(GarbageCollectionType type);
 
  void RequestGarbageCollectionForTesting(GarbageCollectionType type,
                                          StackState stack_state);
 
  void SetEventLogger(LogEventCallback that);
 
  void AddBeforeCallEnteredCallback(BeforeCallEnteredCallback callback);
 
  void RemoveBeforeCallEnteredCallback(BeforeCallEnteredCallback callback);
 
  void AddCallCompletedCallback(CallCompletedCallback callback);
 
  void RemoveCallCompletedCallback(CallCompletedCallback callback);
 
  void SetPromiseHook(PromiseHook hook);
 
  void SetPromiseRejectCallback(PromiseRejectCallback callback);
 
  void PerformMicrotaskCheckpoint();
 
  void EnqueueMicrotask(Local<Function> microtask);
 
  void EnqueueMicrotask(MicrotaskCallback callback, void* data = nullptr);
 
  void SetMicrotasksPolicy(MicrotasksPolicy policy);
 
  MicrotasksPolicy GetMicrotasksPolicy() const;
 
  void AddMicrotasksCompletedCallback(
      MicrotasksCompletedCallbackWithData callback, void* data = nullptr);
 
  void RemoveMicrotasksCompletedCallback(
      MicrotasksCompletedCallbackWithData callback, void* data = nullptr);
 
  void SetUseCounterCallback(UseCounterCallback callback);
 
  void SetCounterFunction(CounterLookupCallback);
 
  void SetCreateHistogramFunction(CreateHistogramCallback);
  void SetAddHistogramSampleFunction(AddHistogramSampleCallback);
 
  void SetMetricsRecorder(
      const std::shared_ptr<metrics::Recorder>& metrics_recorder);
 
  void SetAddCrashKeyCallback(AddCrashKeyCallback);
 
  V8_DEPRECATE_SOON(
      "Use MemoryPressureNotification() to influence the GC schedule.")
  bool IdleNotificationDeadline(double deadline_in_seconds);
 
  void LowMemoryNotification();
 
  int ContextDisposedNotification(bool dependant_context = true);
 
  void IsolateInForegroundNotification();
 
  void IsolateInBackgroundNotification();
 
  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
  void EnableMemorySavingsMode();
 
  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
  void DisableMemorySavingsMode();
 
  void SetRAILMode(RAILMode rail_mode);
 
  void UpdateLoadStartTime();
 
  void IncreaseHeapLimitForDebugging();
 
  void RestoreOriginalHeapLimit();
 
  bool IsHeapLimitIncreasedForDebugging();
 
  void SetJitCodeEventHandler(JitCodeEventOptions options,
                              JitCodeEventHandler event_handler);
 
  void SetStackLimit(uintptr_t stack_limit);
 
  void GetCodeRange(void** start, size_t* length_in_bytes);
 
  void GetEmbeddedCodeRange(const void** start, size_t* length_in_bytes);
 
  JSEntryStubs GetJSEntryStubs();
 
  static constexpr size_t kMinCodePagesBufferSize = 32;
 
  size_t CopyCodePages(size_t capacity, MemoryRange* code_pages_out);
 
  void SetFatalErrorHandler(FatalErrorCallback that);
 
  void SetOOMErrorHandler(OOMErrorCallback that);
 
  void AddNearHeapLimitCallback(NearHeapLimitCallback callback, void* data);
 
  void RemoveNearHeapLimitCallback(NearHeapLimitCallback callback,
                                   size_t heap_limit);
 
  void AutomaticallyRestoreInitialHeapLimit(double threshold_percent = 0.5);
 
  void SetModifyCodeGenerationFromStringsCallback(
      ModifyCodeGenerationFromStringsCallback2 callback);
 
  void SetAllowWasmCodeGenerationCallback(
      AllowWasmCodeGenerationCallback callback);
 
  void SetWasmModuleCallback(ExtensionCallback callback);
  void SetWasmInstanceCallback(ExtensionCallback callback);
 
  void SetWasmStreamingCallback(WasmStreamingCallback callback);
 
  void SetWasmAsyncResolvePromiseCallback(
      WasmAsyncResolvePromiseCallback callback);
 
  void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
  V8_DEPRECATED("Wasm SIMD is always enabled")
  void SetWasmSimdEnabledCallback(WasmSimdEnabledCallback callback);
 
  V8_DEPRECATED("Wasm exceptions are always enabled")
  void SetWasmExceptionsEnabledCallback(WasmExceptionsEnabledCallback callback);
 
  void SetWasmGCEnabledCallback(WasmGCEnabledCallback callback);
 
  void SetSharedArrayBufferConstructorEnabledCallback(
      SharedArrayBufferConstructorEnabledCallback callback);
 
  void InstallConditionalFeatures(Local<Context> context);
 
  bool IsDead();
 
  bool AddMessageListener(MessageCallback that,
                          Local<Value> data = Local<Value>());
 
  bool AddMessageListenerWithErrorLevel(MessageCallback that,
                                        int message_levels,
                                        Local<Value> data = Local<Value>());
 
  void RemoveMessageListeners(MessageCallback that);
 
  void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
 
  void SetCaptureStackTraceForUncaughtExceptions(
      bool capture, int frame_limit = 10,
      StackTrace::StackTraceOptions options = StackTrace::kOverview);
 
  void VisitExternalResources(ExternalResourceVisitor* visitor);
 
  bool IsInUse();
 
  void SetAllowAtomicsWait(bool allow);
 
  enum class TimeZoneDetection { kSkip, kRedetect };
 
  void DateTimeConfigurationChangeNotification(
      TimeZoneDetection time_zone_detection = TimeZoneDetection::kSkip);
 
  void LocaleConfigurationChangeNotification();
 
  Isolate() = delete;
  ~Isolate() = delete;
  Isolate(const Isolate&) = delete;
  Isolate& operator=(const Isolate&) = delete;
  // Deleting operator new and delete here is allowed as ctor and dtor is also
  // deleted.
  void* operator new(size_t size) = delete;
  void* operator new[](size_t size) = delete;
  void operator delete(void*, size_t) = delete;
  void operator delete[](void*, size_t) = delete;
 
 private:
  template <class K, class V, class Traits>
  friend class PersistentValueMapBase;
 
  internal::Address* GetDataFromSnapshotOnce(size_t index);
  void ReportExternalAllocationLimitReached();
};
 
void Isolate::SetData(uint32_t slot, void* data) {
  using I = internal::Internals;
  I::SetEmbedderData(this, slot, data);
}
 
void* Isolate::GetData(uint32_t slot) {
  using I = internal::Internals;
  return I::GetEmbedderData(this, slot);
}
 
uint32_t Isolate::GetNumberOfDataSlots() {
  using I = internal::Internals;
  return I::kNumIsolateDataSlots;
}
 
template <class T>
MaybeLocal<T> Isolate::GetDataFromSnapshotOnce(size_t index) {
  T* data =
      internal::ValueHelper::SlotAsValue<T>(GetDataFromSnapshotOnce(index));
  if (data) internal::PerformCastCheck(data);
  return Local<T>(data);
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_ISOLATE_H_