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 Allocator;
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);
 
using V8FatalErrorCallback = 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 SetFatalErrorHandler(V8FatalErrorCallback 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() {
#ifdef V8_TARGET_OS_ANDROID
    const bool kV8TargetOsIsAndroid = true;
#else
    const bool kV8TargetOsIsAndroid = false;
#endif
 
#ifdef V8_ENABLE_CHECKS
    const bool kV8EnableChecks = true;
#else
    const bool kV8EnableChecks = false;
#endif
 
    const int kBuildConfiguration =
        (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
        (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
        (internal::SandboxIsEnabled() ? kSandbox : 0) |
        (kV8TargetOsIsAndroid ? kTargetOsIsAndroid : 0) |
        (kV8EnableChecks ? kEnableChecks : 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();
 
#if defined(V8_ENABLE_SANDBOX)
  enum class SandboxMode : uint8_t {
    kSecure = 0,
    kInsecure = 1,
    kInsecurePartialReservationSmiInaccessible = 2,
    kInsecureFullReservationSmiAccessible = 3,
    kInsecurePartialReservationSmiAccessible = 4,
 
    kMaxValue = kInsecurePartialReservationSmiAccessible,
  };
 
  static SandboxMode GetSandboxMode();
 
  static bool IsSandboxConfiguredSecurely();
 
  static VirtualAddressSpace* GetSandboxAddressSpace();
 
  static size_t GetSandboxSizeInBytes();
 
  static size_t GetSandboxReservationSizeInBytes();
 
  static void SetInSandboxAllocator(std::shared_ptr<Allocator> allocator);
#endif  // V8_ENABLE_SANDBOX
 
  enum class WasmMemoryType {
    kMemory32,
    kMemory64,
  };
 
  static size_t GetWasmMemoryReservationSizeInBytes(WasmMemoryType type,
                                                    size_t byte_capacity);
 
  static bool EnableWebAssemblyTrapHandler(bool use_v8_signal_handler);
 
#if defined(V8_OS_WIN)
  static void SetUnhandledExceptionCallback(
      UnhandledExceptionCallback callback);
#endif
 
  static void SetFatalMemoryErrorCallback(OOMErrorCallback callback);
 
  static void GetSharedMemoryStatistics(SharedMemoryStatistics* statistics);
 
 private:
  V8();
 
  enum BuildConfigurationFeatures {
    kPointerCompression = 1 << 0,
    k31BitSmis = 1 << 1,
    kSandbox = 1 << 2,
    kTargetOsIsAndroid = 1 << 3,
    kEnableChecks = 1 << 4,
  };
 
  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_