v8-initialization.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_INITIALIZATION_H_
#define INCLUDE_V8_INITIALIZATION_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include "v8-callbacks.h"  // NOLINT(build/include_directory)
#include "v8-internal.h"   // NOLINT(build/include_directory)
#include "v8-isolate.h"    // NOLINT(build/include_directory)
#include "v8-platform.h"   // NOLINT(build/include_directory)
#include "v8config.h"      // NOLINT(build/include_directory)
 
// We reserve the V8_* prefix for macros defined in V8 public API and
// assume there are no name conflicts with the embedder's code.
 
namespace v8 {
 
class PageAllocator;
class Platform;
template <class K, class V, class T>
class PersistentValueMapBase;
 
using EntropySource = bool (*)(unsigned char* buffer, size_t length);
 
using ReturnAddressLocationResolver =
    uintptr_t (*)(uintptr_t return_addr_location);
 
using DcheckErrorCallback = void (*)(const char* file, int line,
                                     const char* message);
 
class V8_EXPORT V8 {
 public:
  static void SetSnapshotDataBlob(StartupData* startup_blob);
 
  static void SetDcheckErrorHandler(DcheckErrorCallback that);
 
  static void SetFlagsFromString(const char* str);
  static void SetFlagsFromString(const char* str, size_t length);
 
  static void SetFlagsFromCommandLine(int* argc, char** argv,
                                      bool remove_flags);
 
  static const char* GetVersion();
 
  V8_INLINE static bool Initialize() {
    const int kBuildConfiguration =
        (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
        (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
        (internal::SandboxedExternalPointersAreEnabled()
             ? kSandboxedExternalPointers
             : 0) |
        (internal::SandboxIsEnabled() ? kSandbox : 0);
    return Initialize(kBuildConfiguration);
  }
 
  static void SetEntropySource(EntropySource source);
 
  static void SetReturnAddressLocationResolver(
      ReturnAddressLocationResolver return_address_resolver);
 
  static bool Dispose();
 
  static bool InitializeICU(const char* icu_data_file = nullptr);
 
  static bool InitializeICUDefaultLocation(const char* exec_path,
                                           const char* icu_data_file = nullptr);
 
  static void InitializeExternalStartupData(const char* directory_path);
  static void InitializeExternalStartupDataFromFile(const char* snapshot_blob);
 
  static void InitializePlatform(Platform* platform);
 
  static void DisposePlatform();
  V8_DEPRECATED("Use DisposePlatform()")
  static void ShutdownPlatform() { DisposePlatform(); }
 
#ifdef V8_SANDBOX
  //
  // Sandbox related API.
  //
  // This API is not yet stable and subject to changes in the future.
  //
 
  static bool InitializeSandbox();
  V8_DEPRECATE_SOON("Use InitializeSandbox()")
  static bool InitializeVirtualMemoryCage() { return InitializeSandbox(); }
 
  static VirtualAddressSpace* GetSandboxAddressSpace();
  V8_DEPRECATE_SOON("Use GetSandboxAddressSpace()")
  static PageAllocator* GetVirtualMemoryCagePageAllocator();
 
  static size_t GetSandboxSizeInBytes();
  V8_DEPRECATE_SOON("Use GetSandboxSizeInBytes()")
  static size_t GetVirtualMemoryCageSizeInBytes() {
    return GetSandboxSizeInBytes();
  }
 
  static bool IsSandboxConfiguredSecurely();
  V8_DEPRECATE_SOON("Use IsSandboxConfiguredSecurely()")
  static bool IsUsingSecureVirtualMemoryCage() {
    return IsSandboxConfiguredSecurely();
  }
#endif
 
  static bool EnableWebAssemblyTrapHandler(bool use_v8_signal_handler);
 
#if defined(V8_OS_WIN)
  static void SetUnhandledExceptionCallback(
      UnhandledExceptionCallback unhandled_exception_callback);
#endif
 
  static void SetFatalMemoryErrorCallback(OOMErrorCallback oom_error_callback);
 
  static void GetSharedMemoryStatistics(SharedMemoryStatistics* statistics);
 
 private:
  V8();
 
  enum BuildConfigurationFeatures {
    kPointerCompression = 1 << 0,
    k31BitSmis = 1 << 1,
    kSandboxedExternalPointers = 1 << 2,
    kSandbox = 1 << 3,
  };
 
  static bool Initialize(int build_config);
 
  friend class Context;
  template <class K, class V, class T>
  friend class PersistentValueMapBase;
};
 
}  // namespace v8
 
#endif  // INCLUDE_V8_INITIALIZATION_H_