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 <functional>
#include <memory>
#include <string>
#include <utility>
 
#include "cppgc/common.h"
#include "cppgc/macros.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-exception.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;
  }
 
  uint64_t physical_memory_size_in_bytes() const {
    return physical_memory_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;
  uint64_t physical_memory_size_ = 0;
  uint32_t* stack_limit_ = nullptr;
};
 
enum class MemoryPressureLevel { kNone, kModerate, kCritical };
 
enum class ContextDependants {
  kNoDependants,
  kSomeDependants
};
 
using StackState = cppgc::EmbedderStackState;
 
class V8_EXPORT IsolateGroup {
 public:
  static IsolateGroup GetDefault();
 
  static bool CanCreateNewGroups();
 
  static IsolateGroup Create();
 
  IsolateGroup(IsolateGroup&& other);
  IsolateGroup& operator=(IsolateGroup&& other);
 
  IsolateGroup(const IsolateGroup&);
  IsolateGroup& operator=(const IsolateGroup&);
 
  ~IsolateGroup();
 
  bool operator==(const IsolateGroup& other) const {
    return isolate_group_ == other.isolate_group_;
  }
 
  bool operator!=(const IsolateGroup& other) const {
    return !operator==(other);
  }
 
#ifdef V8_ENABLE_SANDBOX
  bool SandboxContains(void* pointer) const;
  VirtualAddressSpace* GetSandboxAddressSpace();
#else
  V8_INLINE bool SandboxContains(void* pointer) const { return true; }
#endif
 
 private:
  friend class Isolate;
  friend class ArrayBuffer::Allocator;
 
  // The isolate_group pointer should be already acquired.
  explicit IsolateGroup(internal::IsolateGroup*&& isolate_group);
 
  internal::IsolateGroup* isolate_group_;
};
 
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;
 
    FatalErrorCallback fatal_error_callback = nullptr;
    OOMErrorCallback oom_error_callback = nullptr;
 
    CppHeap* cpp_heap = 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 {
    CPPGC_STACK_ALLOCATED();
 
   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;
  };
 
  enum GarbageCollectionType {
    kFullGarbageCollection,
    kMinorGarbageCollection
  };
 
  enum UseCounterFeature {
    kUseAsm = 0,
    kBreakIterator = 1,
    kOBSOLETE_LegacyConst = 2,
    kOBSOLETE_MarkDequeOverflow = 3,
    kOBSOLETE_StoreBufferOverflow = 4,
    kOBSOLETE_SlotsBufferOverflow = 5,
    kOBSOLETE_ObjectObserve = 6,
    kForcedGC = 7,
    kSloppyMode = 8,
    kStrictMode = 9,
    kOBSOLETE_StrongMode = 10,
    kRegExpPrototypeStickyGetter = 11,
    kRegExpPrototypeToString = 12,
    kRegExpPrototypeUnicodeGetter = 13,
    kOBSOLETE_IntlV8Parse = 14,
    kOBSOLETE_IntlPattern = 15,
    kOBSOLETE_IntlResolved = 16,
    kOBSOLETE_PromiseChain = 17,
    kOBSOLETE_PromiseAccept = 18,
    kOBSOLETE_PromiseDefer = 19,
    kHtmlCommentInExternalScript = 20,
    kHtmlComment = 21,
    kSloppyModeBlockScopedFunctionRedefinition = 22,
    kForInInitializer = 23,
    kOBSOLETE_ArrayProtectorDirtied = 24,
    kArraySpeciesModified = 25,
    kArrayPrototypeConstructorModified = 26,
    kOBSOLETE_ArrayInstanceProtoModified = 27,
    kArrayInstanceConstructorModified = 28,
    kOBSOLETE_LegacyFunctionDeclaration = 29,
    kOBSOLETE_RegExpPrototypeSourceGetter = 30,
    kOBSOLETE_RegExpPrototypeOldFlagGetter = 31,
    kDecimalWithLeadingZeroInStrictMode = 32,
    kLegacyDateParser = 33,
    kDefineGetterOrSetterWouldThrow = 34,
    kFunctionConstructorReturnedUndefined = 35,
    kAssigmentExpressionLHSIsCallInSloppy = 36,
    kAssigmentExpressionLHSIsCallInStrict = 37,
    kPromiseConstructorReturnedUndefined = 38,
    kOBSOLETE_ConstructorNonUndefinedPrimitiveReturn = 39,
    kOBSOLETE_LabeledExpressionStatement = 40,
    kOBSOLETE_LineOrParagraphSeparatorAsLineTerminator = 41,
    kIndexAccessor = 42,
    kErrorCaptureStackTrace = 43,
    kErrorPrepareStackTrace = 44,
    kErrorStackTraceLimit = 45,
    kWebAssemblyInstantiation = 46,
    kDeoptimizerDisableSpeculation = 47,
    kOBSOLETE_ArrayPrototypeSortJSArrayModifiedPrototype = 48,
    kFunctionTokenOffsetTooLongForToString = 49,
    kWasmSharedMemory = 50,
    kWasmThreadOpcodes = 51,
    kOBSOLETE_AtomicsNotify = 52,
    kOBSOLETE_AtomicsWake = 53,
    kCollator = 54,
    kNumberFormat = 55,
    kDateTimeFormat = 56,
    kPluralRules = 57,
    kRelativeTimeFormat = 58,
    kLocale = 59,
    kListFormat = 60,
    kSegmenter = 61,
    kStringLocaleCompare = 62,
    kOBSOLETE_StringToLocaleUpperCase = 63,
    kStringToLocaleLowerCase = 64,
    kNumberToLocaleString = 65,
    kDateToLocaleString = 66,
    kDateToLocaleDateString = 67,
    kDateToLocaleTimeString = 68,
    kAttemptOverrideReadOnlyOnPrototypeSloppy = 69,
    kAttemptOverrideReadOnlyOnPrototypeStrict = 70,
    kOBSOLETE_OptimizedFunctionWithOneShotBytecode = 71,
    kRegExpMatchIsTrueishOnNonJSRegExp = 72,
    kRegExpMatchIsFalseishOnJSRegExp = 73,
    kOBSOLETE_DateGetTimezoneOffset = 74,
    kStringNormalize = 75,
    kCallSiteAPIGetFunctionSloppyCall = 76,
    kCallSiteAPIGetThisSloppyCall = 77,
    kOBSOLETE_RegExpMatchAllWithNonGlobalRegExp = 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 V8_DEPRECATE_SOON(
        "The ArrayConstructorProtector has been removed") = 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,
    kWasmMultiValue = 110,
    kWasmExceptionHandling = 111,
    kInvalidatedMegaDOMProtector = 112,
    kFunctionPrototypeArguments = 113,
    kFunctionPrototypeCaller = 114,
    kTurboFanOsrCompileStarted = 115,
    kAsyncStackTaggingCreateTaskCall = 116,
    kDurationFormat = 117,
    kInvalidatedNumberStringNotRegexpLikeProtector = 118,
    kOBSOLETE_RegExpUnicodeSetIncompatibilitiesWithUnicodeMode = 119,
    kOBSOLETE_ImportAssertionDeprecatedSyntax = 120,
    kLocaleInfoObsoletedGetters = 121,
    kLocaleInfoFunctions = 122,
    kCompileHintsMagicAll = 123,
    kInvalidatedNoProfilingProtector = 124,
    kWasmMemory64 = 125,
    kWasmMultiMemory = 126,
    kWasmGC = 127,
    kWasmImportedStrings = 128,
    kSourceMappingUrlMagicCommentAtSign = 129,
    kTemporalObject = 130,
    kWasmModuleCompilation = 131,
    kInvalidatedNoUndetectableObjectsProtector = 132,
    kWasmJavaScriptPromiseIntegration = 133,
    kWasmReturnCall = 134,
    kWasmExtendedConst = 135,
    kWasmRelaxedSimd = 136,
    kWasmTypeReflection = 137,
    kWasmExnRef = 138,
    kWasmTypedFuncRef = 139,
    kInvalidatedStringWrapperToPrimitiveProtector = 140,
    kDocumentAllLegacyCall = 141,
    kDocumentAllLegacyConstruct = 142,
    kConsoleContext = 143,
    kWasmImportedStringsUtf8 = 144,
    kResizableArrayBuffer = 145,
    kGrowableSharedArrayBuffer = 146,
    kArrayByCopy = 147,
    kArrayFromAsync = 148,
    kIteratorMethods = 149,
    kPromiseAny = 150,
    kSetMethods = 151,
    kArrayFindLast = 152,
    kArrayGroup = 153,
    kArrayBufferTransfer = 154,
    kPromiseWithResolvers = 155,
    kAtomicsWaitAsync = 156,
    kExtendingNonExtensibleWithPrivate = 157,
    kPromiseTry = 158,
    kStringReplaceAll = 159,
    kStringWellFormed = 160,
    kWeakReferences = 161,
    kErrorIsError = 162,
    kInvalidatedTypedArrayLengthLookupChainProtector = 163,
    kRegExpEscape = 164,
    kFloat16Array = 165,
    kExplicitResourceManagement = 166,
    kWasmBranchHinting = 167,
    kWasmMutableGlobals = 168,
    kUint8ArrayToFromBase64AndHex = 169,
    kAtomicsPause = 170,
    kTopLevelAwait = 171,
    kLogicalAssignment = 172,
    kNullishCoalescing = 173,
    kInvalidatedNoDateTimeConfigurationChangeProtector = 174,
    kWasmNonTrappingFloatToInt = 175,
    kWasmSignExtensionOps = 176,
    kRegExpCompile = 177,
    kRegExpStaticProperties = 178,
    kRegExpStaticPropertiesWithLastMatch = 179,
    kWithStatement = 180,
    kHtmlWrapperMethods = 181,
    kWasmCustomDescriptors = 182,
    kOBSOLETE_WasmResizableBuffers = 183,
    kInvalidatedArrayBufferMutableProtector = 184,
    kHoleyArrayReadthrough = 185,
 
    // 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,
  };
 
  // The different priorities that an isolate can have.
  enum class Priority {
    // The isolate does not relate to content that is currently important
    // to the user. Lowest priority.
    kBestEffort,
 
    // The isolate contributes to content that is visible to the user, like a
    // visible iframe that's not interacted directly with. High priority.
    kUserVisible,
 
    // The isolate contributes to content that is of the utmost importance to
    // the user, like visible content in the focused window. Highest priority.
    kUserBlocking,
  };
 
  using UseCounterCallback = void (*)(Isolate* isolate,
                                      UseCounterFeature feature);
 
  static Isolate* Allocate();
  static Isolate* Allocate(const IsolateGroup& group);
 
  IsolateGroup GetGroup() const;
 
  static void Initialize(Isolate* isolate, const CreateParams& params);
 
  static Isolate* New(const CreateParams& params);
  static Isolate* New(const IsolateGroup& group, 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 SetHostImportModuleWithPhaseDynamicallyCallback(
      HostImportModuleWithPhaseDynamicallyCallback callback);
 
  void SetHostInitializeImportMetaObjectCallback(
      HostInitializeImportMetaObjectCallback callback);
 
  void SetHostCreateShadowRealmContextCallback(
      HostCreateShadowRealmContextCallback callback);
 
  void SetIsJSApiWrapperNativeErrorCallback(
      IsJSApiWrapperNativeErrorCallback callback);
 
  void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback);
 
  int GetStackTraceLimit();
 
#if defined(V8_OS_WIN)
  V8_DEPRECATE_SOON("Use SetFilterETWSessionByURL2Callback instead")
  void SetFilterETWSessionByURLCallback(FilterETWSessionByURLCallback callback);
  void SetFilterETWSessionByURL2Callback(
      FilterETWSessionByURL2Callback callback);
#endif  // V8_OS_WIN
 
  void MemoryPressureNotification(MemoryPressureLevel level);
 
  bool RetryCustomAllocate(std::function<bool()> allocate);
 
  void SetBatterySaverMode(bool battery_saver_mode_enabled);
 
  void SetMemorySaverMode(bool memory_saver_mode_enabled);
 
  void ClearCachesForTesting();
 
  void Enter();
 
  void Exit();
 
  void Dispose();
 
  void Deinitialize();
 
  static void Free(Isolate* isolate);
 
  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);
 
  V8_DEPRECATED("Use GetContinuationPreservedEmbedderDataV2 instead")
  Local<Value> GetContinuationPreservedEmbedderData();
 
  V8_DEPRECATED("Use SetContinuationPreservedEmbedderDataV2 instead")
  void SetContinuationPreservedEmbedderData(Local<Value> data);
 
  Local<Data> GetContinuationPreservedEmbedderDataV2();
 
  void SetContinuationPreservedEmbedderDataV2(Local<Data> data);
 
  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);
 
  V8_DEPRECATE_SOON("Use ExternalMemoryAccounter instead.")
  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();
 
  MaybeLocal<Data> GetCurrentHostDefinedOptions();
 
  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);
 
  bool HasPendingException();
 
  using GCCallback = void (*)(Isolate* isolate, GCType type,
                              GCCallbackFlags flags);
  using GCCallbackWithData = void (*)(Isolate* isolate, GCType type,
                                      GCCallbackFlags flags, void* data);
 
  void AddGCPrologueCallback(GCCallback callback,
                             GCType gc_type_filter = kGCTypeAll);
 
  void AddGCPrologueCallback(GCCallbackWithData callback, void* data = nullptr,
                             GCType gc_type_filter = kGCTypeAll);
 
  void RemoveGCPrologueCallback(GCCallback callback);
 
  void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
 
  void AddGCEpilogueCallback(GCCallback callback,
                             GCType gc_type_filter = kGCTypeAll);
 
  void AddGCEpilogueCallback(GCCallbackWithData callback, void* data = nullptr,
                             GCType gc_type_filter = kGCTypeAll);
 
  void RemoveGCEpilogueCallback(GCCallback callback);
 
  void RemoveGCEpilogueCallback(GCCallbackWithData callback,
                                void* data = nullptr);
 
  void SetEmbedderRootsHandler(EmbedderRootsHandler* handler);
 
  using ReleaseCppHeapCallback = void (*)(std::unique_ptr<CppHeap>);
 
  void SetReleaseCppHeapCallbackForTesting(ReleaseCppHeapCallback callback);
 
  CppHeap* GetCppHeap() const;
 
  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 SetExceptionPropagationCallback(ExceptionPropagationCallback callback);
 
  void PerformMicrotaskCheckpoint();
 
  V8_DEPRECATE_SOON("Use *MicrotaskQueue::EnqueueMicrotask* instead")
  void EnqueueMicrotask(Local<Function> microtask);
 
  V8_DEPRECATE_SOON("Use *MicrotaskQueue::EnqueueMicrotask* instead")
  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);
 
  void SetCrashKeyStringCallbacks(AllocateCrashKeyStringCallback,
                                  SetCrashKeyStringCallback);
 
  void LowMemoryNotification();
 
  V8_DEPRECATE_SOON("Use version that passes ContextDependants.")
  int ContextDisposedNotification(bool dependant_context = true);
 
  void ContextDisposedNotification(ContextDependants dependants);
 
  V8_DEPRECATE_SOON("Use SetPriority(Priority::kUserBlocking) instead")
  void IsolateInForegroundNotification();
 
  V8_DEPRECATE_SOON("Use SetPriority(Priority::kBestEffort) instead")
  void IsolateInBackgroundNotification();
 
  void SetPriority(Priority priority);
 
  void SetIsLoading(bool is_loading);
 
  void SetIsInputHandling(bool is_input_handling);
 
  void Freeze(bool is_frozen);
 
  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 SetOOMErrorHandler(OOMErrorCallbackWithData that, void* data);
 
  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);
 
  void SetWasmCustomDescriptorsEnabledCallback(
      WasmCustomDescriptorsEnabledCallback callback);
 
  void SetSharedArrayBufferConstructorEnabledCallback(
      SharedArrayBufferConstructorEnabledCallback callback);
 
  void InstallConditionalFeatures(Local<Context> context);
 
  bool IsDead();
 
  bool AddMessageListener(MessageCallback callback,
                          Local<Value> data = Local<Value>());
 
  bool AddMessageListenerWithErrorLevel(MessageCallback callback,
                                        int message_levels,
                                        Local<Value> data = Local<Value>());
 
  void RemoveMessageListeners(MessageCallback callback);
 
  void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
 
  void SetCaptureStackTraceForUncaughtExceptions(
      bool capture, int frame_limit = 10,
      StackTrace::StackTraceOptions options = StackTrace::kOverview);
 
  bool IsInUse();
 
  void SetAllowAtomicsWait(bool allow);
 
  enum class TimeZoneDetection { kSkip, kRedetect };
 
  void DateTimeConfigurationChangeNotification(
      TimeZoneDetection time_zone_detection = TimeZoneDetection::kSkip);
 
  void LocaleConfigurationChangeNotification();
 
  std::string GetDefaultLocale();
 
  V8_WARN_UNUSED_RESULT Maybe<std::string>
  ValidateAndCanonicalizeUnicodeLocaleId(std::string_view locale);
 
  uint64_t GetHashSeed();
 
  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;
  friend class ExternalMemoryAccounter;
 
  internal::ValueHelper::InternalRepresentationType GetDataFromSnapshotOnce(
      size_t index);
  int64_t AdjustAmountOfExternalAllocatedMemoryImpl(int64_t change_in_bytes);
};
 
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) {
  if (auto repr = GetDataFromSnapshotOnce(index);
      repr != internal::ValueHelper::kEmpty) {
    internal::PerformCastCheck(internal::ValueHelper::ReprAsValue<T>(repr));
    return Local<T>::FromRepr(repr);
  }
  return {};
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_ISOLATE_H_