bootstrapper.h

Go to the documentation of this file.

// Copyright 2014 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 V8_INIT_BOOTSTRAPPER_H_
#define V8_INIT_BOOTSTRAPPER_H_
 
#include "include/v8-context.h"
#include "include/v8-local-handle.h"
#include "include/v8-snapshot.h"
#include "src/heap/factory.h"
#include "src/objects/fixed-array.h"
#include "src/objects/shared-function-info.h"
#include "src/objects/visitors.h"
#include "src/snapshot/serializer-deserializer.h"
 
namespace v8 {
namespace internal {
 
// A SourceCodeCache uses a FixedArray to store pairs of (OneByteString,
// SharedFunctionInfo), mapping names of native extensions code files to
// precompiled functions.
class SourceCodeCache final {
 public:
  explicit SourceCodeCache(Script::Type type) : type_(type) {}
  SourceCodeCache(const SourceCodeCache&) = delete;
  SourceCodeCache& operator=(const SourceCodeCache&) = delete;
 
  void Initialize(Isolate* isolate, bool create_heap_objects);
 
  void Iterate(RootVisitor* v);
 
  bool Lookup(Isolate* isolate, base::Vector<const char> name,
              DirectHandle<SharedFunctionInfo>* handle);
 
  void Add(Isolate* isolate, base::Vector<const char> name,
           DirectHandle<SharedFunctionInfo> shared);
 
 private:
  Script::Type type_;
  Tagged<FixedArray> cache_;
};
 
// The Boostrapper is the public interface for creating a JavaScript global
// context.
class Bootstrapper final {
 public:
  Bootstrapper(const Bootstrapper&) = delete;
  Bootstrapper& operator=(const Bootstrapper&) = delete;
 
  static void InitializeOncePerProcess();
 
  // Requires: Heap::SetUp has been called.
  void Initialize(bool create_heap_objects);
  void TearDown();
 
  // Creates a JavaScript Global Context with initial object graph.
  // The returned value is a global handle casted to V8Environment*.
  DirectHandle<NativeContext> CreateEnvironment(
      MaybeDirectHandle<JSGlobalProxy> maybe_global_proxy,
      v8::Local<v8::ObjectTemplate> global_object_template,
      v8::ExtensionConfiguration* extensions, size_t context_snapshot_index,
      DeserializeEmbedderFieldsCallback embedder_fields_deserializer,
      v8::MicrotaskQueue* microtask_queue);
 
  // Used for testing context deserialization. No code runs in the generated
  // context. It only needs to pass heap verification.
  DirectHandle<NativeContext> CreateEnvironmentForTesting() {
    MaybeDirectHandle<JSGlobalProxy> no_global_proxy;
    v8::Local<v8::ObjectTemplate> no_global_object_template;
    ExtensionConfiguration no_extensions;
    static constexpr int kDefaultContextIndex = 0;
    DeserializeEmbedderFieldsCallback no_callback;
    v8::MicrotaskQueue* no_microtask_queue = nullptr;
    return CreateEnvironment(no_global_proxy, no_global_object_template,
                             &no_extensions, kDefaultContextIndex, no_callback,
                             no_microtask_queue);
  }
 
  DirectHandle<JSGlobalProxy> NewRemoteContext(
      MaybeDirectHandle<JSGlobalProxy> maybe_global_proxy,
      v8::Local<v8::ObjectTemplate> global_object_template);
 
  // Traverses the pointers for memory management.
  void Iterate(RootVisitor* v);
 
  // Tells whether bootstrapping is active.
  bool IsActive() const { return nesting_ != 0; }
 
  // Support for thread preemption.
  static int ArchiveSpacePerThread();
  char* ArchiveState(char* to);
  char* RestoreState(char* from);
  void FreeThreadResources();
 
  // Used for new context creation.
  bool InstallExtensions(DirectHandle<NativeContext> native_context,
                         v8::ExtensionConfiguration* extensions);
 
  SourceCodeCache* extensions_cache() { return &extensions_cache_; }
 
 private:
  // Log newly created Map objects if no snapshot was used.
  void LogAllMaps();
 
  Isolate* isolate_;
  using NestingCounterType = int;
  NestingCounterType nesting_;
  SourceCodeCache extensions_cache_;
 
  friend class BootstrapperActive;
  friend class Isolate;
  friend class NativesExternalStringResource;
 
  explicit Bootstrapper(Isolate* isolate);
};
 
class BootstrapperActive final {
 public:
  explicit BootstrapperActive(Bootstrapper* bootstrapper)
      : bootstrapper_(bootstrapper) {
    ++bootstrapper_->nesting_;
  }
  BootstrapperActive(const BootstrapperActive&) = delete;
  BootstrapperActive& operator=(const BootstrapperActive&) = delete;
 
  ~BootstrapperActive() { --bootstrapper_->nesting_; }
 
 private:
  Bootstrapper* bootstrapper_;
};
 
// Exposed for Wasm bootstrapping.
V8_NOINLINE Handle<JSFunction> SimpleInstallFunction(
    Isolate* isolate, DirectHandle<JSObject> base, const char* name,
    Builtin call, int len, AdaptArguments adapt,
    PropertyAttributes attrs = DONT_ENUM);
 
// Exposed for Wasm bootstrapping.
V8_NOINLINE void InstallError(
    Isolate* isolate, DirectHandle<JSObject> global, DirectHandle<String> name,
    int context_index, Builtin error_constructor = Builtin::kErrorConstructor,
    int error_function_length = 1);
 
}  // namespace internal
}  // namespace v8
 
#endif  // V8_INIT_BOOTSTRAPPER_H_