v8-context.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_CONTEXT_H_
#define INCLUDE_V8_CONTEXT_H_
 
#include <stdint.h>
 
#include <vector>
 
#include "v8-data.h"          // NOLINT(build/include_directory)
#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-maybe.h"         // NOLINT(build/include_directory)
#include "v8-snapshot.h"      // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)
 
namespace v8 {
 
class Function;
class MicrotaskQueue;
class Object;
class ObjectTemplate;
class Value;
class String;
 
class V8_EXPORT ExtensionConfiguration {
 public:
  ExtensionConfiguration() : name_count_(0), names_(nullptr) {}
  ExtensionConfiguration(int name_count, const char* names[])
      : name_count_(name_count), names_(names) {}
 
  const char** begin() const { return &names_[0]; }
  const char** end() const { return &names_[name_count_]; }
 
 private:
  const int name_count_;
  const char** names_;
};
 
class V8_EXPORT Context : public Data {
 public:
  Local<Object> Global();
 
  void DetachGlobal();
 
  static Local<Context> New(
      Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
      MaybeLocal<ObjectTemplate> global_template = MaybeLocal<ObjectTemplate>(),
      MaybeLocal<Value> global_object = MaybeLocal<Value>(),
      DeserializeInternalFieldsCallback internal_fields_deserializer =
          DeserializeInternalFieldsCallback(),
      MicrotaskQueue* microtask_queue = nullptr,
      DeserializeContextDataCallback context_data_deserializer =
          DeserializeContextDataCallback());
 
  static MaybeLocal<Context> FromSnapshot(
      Isolate* isolate, size_t context_snapshot_index,
      DeserializeInternalFieldsCallback internal_fields_deserializer =
          DeserializeInternalFieldsCallback(),
      ExtensionConfiguration* extensions = nullptr,
      MaybeLocal<Value> global_object = MaybeLocal<Value>(),
      MicrotaskQueue* microtask_queue = nullptr,
      DeserializeContextDataCallback context_data_deserializer =
          DeserializeContextDataCallback());
 
  static MaybeLocal<Object> NewRemoteContext(
      Isolate* isolate, Local<ObjectTemplate> global_template,
      MaybeLocal<Value> global_object = MaybeLocal<Value>());
 
  void SetSecurityToken(Local<Value> token);
 
  void UseDefaultSecurityToken();
 
  Local<Value> GetSecurityToken();
 
  void Enter();
 
  void Exit();
 
  class DeepFreezeDelegate {
   public:
    virtual bool FreezeEmbedderObjectAndGetChildren(
        Local<Object> obj, LocalVector<Object>& children_out) = 0;
  };
 
  Maybe<void> DeepFreeze(DeepFreezeDelegate* delegate = nullptr);
 
  Isolate* GetIsolate();
 
  MicrotaskQueue* GetMicrotaskQueue();
 
  void SetMicrotaskQueue(MicrotaskQueue* queue);
 
  enum EmbedderDataFields { kDebugIdIndex = 0 };
 
  uint32_t GetNumberOfEmbedderDataFields();
 
  V8_INLINE Local<Value> GetEmbedderData(int index);
 
  Local<Object> GetExtrasBindingObject();
 
  void SetEmbedderData(int index, Local<Value> value);
 
  V8_INLINE void* GetAlignedPointerFromEmbedderData(int index);
 
  void SetAlignedPointerInEmbedderData(int index, void* value);
 
  void AllowCodeGenerationFromStrings(bool allow);
 
  bool IsCodeGenerationFromStringsAllowed() const;
 
  void SetErrorMessageForCodeGenerationFromStrings(Local<String> message);
 
  void SetErrorMessageForWasmCodeGeneration(Local<String> message);
 
  template <class T>
  V8_INLINE MaybeLocal<T> GetDataFromSnapshotOnce(size_t index);
 
  using AbortScriptExecutionCallback = void (*)(Isolate* isolate,
                                                Local<Context> context);
  void SetAbortScriptExecution(AbortScriptExecutionCallback callback);
 
  void SetPromiseHooks(Local<Function> init_hook, Local<Function> before_hook,
                       Local<Function> after_hook,
                       Local<Function> resolve_hook);
 
  bool HasTemplateLiteralObject(Local<Value> object);
  class V8_NODISCARD Scope {
   public:
    explicit V8_INLINE Scope(Local<Context> context) : context_(context) {
      context_->Enter();
    }
    V8_INLINE ~Scope() { context_->Exit(); }
 
   private:
    Local<Context> context_;
  };
 
  class V8_EXPORT V8_NODISCARD BackupIncumbentScope final {
   public:
    explicit BackupIncumbentScope(Local<Context> backup_incumbent_context);
    ~BackupIncumbentScope();
 
   private:
    friend class internal::Isolate;
 
    uintptr_t JSStackComparableAddressPrivate() const {
      return js_stack_comparable_address_;
    }
 
    Local<Context> backup_incumbent_context_;
    uintptr_t js_stack_comparable_address_ = 0;
    const BackupIncumbentScope* prev_ = nullptr;
  };
 
  V8_INLINE static Context* Cast(Data* data);
 
 private:
  friend class Value;
  friend class Script;
  friend class Object;
  friend class Function;
 
  static void CheckCast(Data* obj);
 
  internal::Address* GetDataFromSnapshotOnce(size_t index);
  Local<Value> SlowGetEmbedderData(int index);
  void* SlowGetAlignedPointerFromEmbedderData(int index);
};
 
// --- Implementation ---
 
Local<Value> Context::GetEmbedderData(int index) {
#ifndef V8_ENABLE_CHECKS
  using A = internal::Address;
  using I = internal::Internals;
  A ctx = internal::ValueHelper::ValueAsAddress(this);
  A embedder_data =
      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
  int value_offset =
      I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
  A value = I::ReadRawField<A>(embedder_data, value_offset);
#ifdef V8_COMPRESS_POINTERS
  // We read the full pointer value and then decompress it in order to avoid
  // dealing with potential endiannes issues.
  value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value));
#endif
 
  auto isolate = reinterpret_cast<v8::Isolate*>(
      internal::IsolateFromNeverReadOnlySpaceObject(ctx));
  return Local<Value>::New(isolate, value);
#else
  return SlowGetEmbedderData(index);
#endif
}
 
void* Context::GetAlignedPointerFromEmbedderData(int index) {
#if !defined(V8_ENABLE_CHECKS)
  using A = internal::Address;
  using I = internal::Internals;
  A ctx = internal::ValueHelper::ValueAsAddress(this);
  A embedder_data =
      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
  int value_offset = I::kEmbedderDataArrayHeaderSize +
                     (I::kEmbedderDataSlotSize * index) +
                     I::kEmbedderDataSlotExternalPointerOffset;
  Isolate* isolate = I::GetIsolateForSandbox(ctx);
  return reinterpret_cast<void*>(
      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
          isolate, embedder_data, value_offset));
#else
  return SlowGetAlignedPointerFromEmbedderData(index);
#endif
}
 
template <class T>
MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
  if (auto slot = GetDataFromSnapshotOnce(index); slot) {
    internal::PerformCastCheck(
        internal::ValueHelper::SlotAsValue<T, false>(slot));
    return Local<T>::FromSlot(slot);
  }
  return {};
}
 
Context* Context::Cast(v8::Data* data) {
#ifdef V8_ENABLE_CHECKS
  CheckCast(data);
#endif
  return static_cast<Context*>(data);
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_CONTEXT_H_