libv8 7.3.492.27.1-universal-darwin16

data/vendor/v8/include/v8-inspector-protocol.h

@@ -0,0 +1,13 @@
+// Copyright 2016 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_V8_INSPECTOR_PROTOCOL_H_
+#define V8_V8_INSPECTOR_PROTOCOL_H_
+
+#include "inspector/Debugger.h"  // NOLINT(build/include)
+#include "inspector/Runtime.h"   // NOLINT(build/include)
+#include "inspector/Schema.h"    // NOLINT(build/include)
+#include "v8-inspector.h"        // NOLINT(build/include)
+
+#endif  // V8_V8_INSPECTOR_PROTOCOL_H_

data/vendor/v8/include/v8-inspector.h

@@ -0,0 +1,296 @@
+// Copyright 2016 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_V8_INSPECTOR_H_
+#define V8_V8_INSPECTOR_H_
+
+#include <stdint.h>
+#include <cctype>
+
+#include <memory>
+
+#include "v8.h"  // NOLINT(build/include)
+
+namespace v8_inspector {
+
+namespace protocol {
+namespace Debugger {
+namespace API {
+class SearchMatch;
+}
+}
+namespace Runtime {
+namespace API {
+class RemoteObject;
+class StackTrace;
+}
+}
+namespace Schema {
+namespace API {
+class Domain;
+}
+}
+}  // namespace protocol
+
+class V8_EXPORT StringView {
+ public:
+  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
+
+  StringView(const uint8_t* characters, size_t length)
+      : m_is8Bit(true), m_length(length), m_characters8(characters) {}
+
+  StringView(const uint16_t* characters, size_t length)
+      : m_is8Bit(false), m_length(length), m_characters16(characters) {}
+
+  bool is8Bit() const { return m_is8Bit; }
+  size_t length() const { return m_length; }
+
+  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
+  // here.
+  const uint8_t* characters8() const { return m_characters8; }
+  const uint16_t* characters16() const { return m_characters16; }
+
+ private:
+  bool m_is8Bit;
+  size_t m_length;
+  union {
+    const uint8_t* m_characters8;
+    const uint16_t* m_characters16;
+  };
+};
+
+class V8_EXPORT StringBuffer {
+ public:
+  virtual ~StringBuffer() = default;
+  virtual const StringView& string() = 0;
+  // This method copies contents.
+  static std::unique_ptr<StringBuffer> create(const StringView&);
+};
+
+class V8_EXPORT V8ContextInfo {
+ public:
+  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
+                const StringView& humanReadableName)
+      : context(context),
+        contextGroupId(contextGroupId),
+        humanReadableName(humanReadableName),
+        hasMemoryOnConsole(false) {}
+
+  v8::Local<v8::Context> context;
+  // Each v8::Context is a part of a group. The group id must be non-zero.
+  int contextGroupId;
+  StringView humanReadableName;
+  StringView origin;
+  StringView auxData;
+  bool hasMemoryOnConsole;
+
+  static int executionContextId(v8::Local<v8::Context> context);
+
+ private:
+  // Disallow copying and allocating this one.
+  enum NotNullTagEnum { NotNullLiteral };
+  void* operator new(size_t) = delete;
+  void* operator new(size_t, NotNullTagEnum, void*) = delete;
+  void* operator new(size_t, void*) = delete;
+  V8ContextInfo(const V8ContextInfo&) = delete;
+  V8ContextInfo& operator=(const V8ContextInfo&) = delete;
+};
+
+class V8_EXPORT V8StackTrace {
+ public:
+  virtual StringView firstNonEmptySourceURL() const = 0;
+  virtual bool isEmpty() const = 0;
+  virtual StringView topSourceURL() const = 0;
+  virtual int topLineNumber() const = 0;
+  virtual int topColumnNumber() const = 0;
+  virtual StringView topScriptId() const = 0;
+  virtual StringView topFunctionName() const = 0;
+
+  virtual ~V8StackTrace() = default;
+  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
+  buildInspectorObject() const = 0;
+  virtual std::unique_ptr<StringBuffer> toString() const = 0;
+
+  // Safe to pass between threads, drops async chain.
+  virtual std::unique_ptr<V8StackTrace> clone() = 0;
+};
+
+class V8_EXPORT V8InspectorSession {
+ public:
+  virtual ~V8InspectorSession() = default;
+
+  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
+  class V8_EXPORT Inspectable {
+   public:
+    virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
+    virtual ~Inspectable() = default;
+  };
+  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
+
+  // Dispatching protocol messages.
+  static bool canDispatchMethod(const StringView& method);
+  virtual void dispatchProtocolMessage(const StringView& message) = 0;
+  virtual std::unique_ptr<StringBuffer> stateJSON() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
+  supportedDomains() = 0;
+
+  // Debugger actions.
+  virtual void schedulePauseOnNextStatement(const StringView& breakReason,
+                                            const StringView& breakDetails) = 0;
+  virtual void cancelPauseOnNextStatement() = 0;
+  virtual void breakProgram(const StringView& breakReason,
+                            const StringView& breakDetails) = 0;
+  virtual void setSkipAllPauses(bool) = 0;
+  virtual void resume() = 0;
+  virtual void stepOver() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
+  searchInTextByLines(const StringView& text, const StringView& query,
+                      bool caseSensitive, bool isRegex) = 0;
+
+  // Remote objects.
+  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, const StringView& groupName,
+      bool generatePreview) = 0;
+
+  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
+                            const StringView& objectId, v8::Local<v8::Value>*,
+                            v8::Local<v8::Context>*,
+                            std::unique_ptr<StringBuffer>* objectGroup) = 0;
+  virtual void releaseObjectGroup(const StringView&) = 0;
+};
+
+class V8_EXPORT V8InspectorClient {
+ public:
+  virtual ~V8InspectorClient() = default;
+
+  virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void quitMessageLoopOnPause() {}
+  virtual void runIfWaitingForDebugger(int contextGroupId) {}
+
+  virtual void muteMetrics(int contextGroupId) {}
+  virtual void unmuteMetrics(int contextGroupId) {}
+
+  virtual void beginUserGesture() {}
+  virtual void endUserGesture() {}
+
+  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>) {
+    return false;
+  }
+  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
+
+  virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
+      int contextGroupId) {
+    return v8::Local<v8::Context>();
+  }
+  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
+  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
+
+  virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
+                                               v8::Local<v8::Object>) {}
+  virtual void consoleAPIMessage(int contextGroupId,
+                                 v8::Isolate::MessageErrorLevel level,
+                                 const StringView& message,
+                                 const StringView& url, unsigned lineNumber,
+                                 unsigned columnNumber, V8StackTrace*) {}
+  virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
+                                               v8::Local<v8::Context>) {
+    return v8::MaybeLocal<v8::Value>();
+  }
+
+  virtual void consoleTime(const StringView& title) {}
+  virtual void consoleTimeEnd(const StringView& title) {}
+  virtual void consoleTimeStamp(const StringView& title) {}
+  virtual void consoleClear(int contextGroupId) {}
+  virtual double currentTimeMS() { return 0; }
+  typedef void (*TimerCallback)(void*);
+  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
+  virtual void cancelTimer(void* data) {}
+
+  // TODO(dgozman): this was added to support service worker shadow page. We
+  // should not connect at all.
+  virtual bool canExecuteScripts(int contextGroupId) { return true; }
+
+  virtual void maxAsyncCallStackDepthChanged(int depth) {}
+
+  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
+      const StringView& resourceName) {
+    return nullptr;
+  }
+};
+
+// These stack trace ids are intended to be passed between debuggers and be
+// resolved later. This allows to track cross-debugger calls and step between
+// them if a single client connects to multiple debuggers.
+struct V8_EXPORT V8StackTraceId {
+  uintptr_t id;
+  std::pair<int64_t, int64_t> debugger_id;
+
+  V8StackTraceId();
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
+  ~V8StackTraceId() = default;
+
+  bool IsInvalid() const;
+};
+
+class V8_EXPORT V8Inspector {
+ public:
+  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
+  virtual ~V8Inspector() = default;
+
+  // Contexts instrumentation.
+  virtual void contextCreated(const V8ContextInfo&) = 0;
+  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
+  virtual void resetContextGroup(int contextGroupId) = 0;
+  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
+
+  // Various instrumentation.
+  virtual void idleStarted() = 0;
+  virtual void idleFinished() = 0;
+
+  // Async stack traces instrumentation.
+  virtual void asyncTaskScheduled(const StringView& taskName, void* task,
+                                  bool recurring) = 0;
+  virtual void asyncTaskCanceled(void* task) = 0;
+  virtual void asyncTaskStarted(void* task) = 0;
+  virtual void asyncTaskFinished(void* task) = 0;
+  virtual void allAsyncTasksCanceled() = 0;
+
+  virtual V8StackTraceId storeCurrentStackTrace(
+      const StringView& description) = 0;
+  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
+  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
+
+  // Exceptions instrumentation.
+  virtual unsigned exceptionThrown(
+      v8::Local<v8::Context>, const StringView& message,
+      v8::Local<v8::Value> exception, const StringView& detailedMessage,
+      const StringView& url, unsigned lineNumber, unsigned columnNumber,
+      std::unique_ptr<V8StackTrace>, int scriptId) = 0;
+  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
+                                const StringView& message) = 0;
+
+  // Connection.
+  class V8_EXPORT Channel {
+   public:
+    virtual ~Channel() = default;
+    virtual void sendResponse(int callId,
+                              std::unique_ptr<StringBuffer> message) = 0;
+    virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
+    virtual void flushProtocolNotifications() = 0;
+  };
+  virtual std::unique_ptr<V8InspectorSession> connect(
+      int contextGroupId, Channel*, const StringView& state) = 0;
+
+  // API methods.
+  virtual std::unique_ptr<V8StackTrace> createStackTrace(
+      v8::Local<v8::StackTrace>) = 0;
+  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_V8_INSPECTOR_H_

data/vendor/v8/include/v8-internal.h

@@ -0,0 +1,373 @@
+// Copyright 2018 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_INTERNAL_H_
+#define INCLUDE_V8_INTERNAL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <type_traits>
+
+#include "v8-version.h"  // NOLINT(build/include)
+#include "v8config.h"    // NOLINT(build/include)
+
+namespace v8 {
+
+class Context;
+class Data;
+class Isolate;
+
+namespace internal {
+
+class Isolate;
+
+typedef uintptr_t Address;
+static const Address kNullAddress = 0;
+
+/**
+ * Configuration of tagging scheme.
+ */
+const int kApiSystemPointerSize = sizeof(void*);
+const int kApiTaggedSize = kApiSystemPointerSize;
+const int kApiDoubleSize = sizeof(double);
+const int kApiIntSize = sizeof(int);
+const int kApiInt64Size = sizeof(int64_t);
+
+// Tag information for HeapObject.
+const int kHeapObjectTag = 1;
+const int kWeakHeapObjectTag = 3;
+const int kHeapObjectTagSize = 2;
+const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
+
+// Tag information for Smi.
+const int kSmiTag = 0;
+const int kSmiTagSize = 1;
+const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
+
+template <size_t tagged_ptr_size>
+struct SmiTagging;
+
+// Smi constants for systems where tagged pointer is a 32-bit value.
+template <>
+struct SmiTagging<4> {
+  enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
+  V8_INLINE static int SmiToInt(const internal::Address value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Shift down (requires >> to be sign extending).
+    return static_cast<int>(static_cast<intptr_t>(value)) >> shift_bits;
+  }
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    // To be representable as an tagged small integer, the two
+    // most-significant bits of 'value' must be either 00 or 11 due to
+    // sign-extension. To check this we add 01 to the two
+    // most-significant bits, and check if the most-significant bit is 0.
+    //
+    // CAUTION: The original code below:
+    // bool result = ((value + 0x40000000) & 0x80000000) == 0;
+    // may lead to incorrect results according to the C language spec, and
+    // in fact doesn't work correctly with gcc4.1.1 in some cases: The
+    // compiler may produce undefined results in case of signed integer
+    // overflow. The computation must be done w/ unsigned ints.
+    return static_cast<uintptr_t>(value) + 0x40000000U < 0x80000000U;
+  }
+};
+
+// Smi constants for systems where tagged pointer is a 64-bit value.
+template <>
+struct SmiTagging<8> {
+  enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
+  V8_INLINE static int SmiToInt(const internal::Address value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Shift down and throw away top 32 bits.
+    return static_cast<int>(static_cast<intptr_t>(value) >> shift_bits);
+  }
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    // To be representable as a long smi, the value must be a 32-bit integer.
+    return (value == static_cast<int32_t>(value));
+  }
+};
+
+#if defined(V8_COMPRESS_POINTERS)
+static_assert(
+    kApiSystemPointerSize == kApiInt64Size,
+    "Pointer compression can be enabled only for 64-bit architectures");
+#endif
+
+#if defined(V8_COMPRESS_POINTERS) || defined(V8_31BIT_SMIS_ON_64BIT_ARCH)
+typedef SmiTagging<kApiIntSize> PlatformSmiTagging;
+#else
+typedef SmiTagging<kApiSystemPointerSize> PlatformSmiTagging;
+#endif
+
+const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
+const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
+const int kSmiMinValue = (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
+const int kSmiMaxValue = -(kSmiMinValue + 1);
+constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; }
+constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; }
+
+V8_INLINE static constexpr internal::Address IntToSmi(int value) {
+  return (static_cast<Address>(value) << (kSmiTagSize + kSmiShiftSize)) |
+         kSmiTag;
+}
+
+/**
+ * This class exports constants and functionality from within v8 that
+ * is necessary to implement inline functions in the v8 api.  Don't
+ * depend on functions and constants defined here.
+ */
+class Internals {
+ public:
+  // These values match non-compiler-dependent values defined within
+  // the implementation of v8.
+  static const int kHeapObjectMapOffset = 0;
+  static const int kMapInstanceTypeOffset = 1 * kApiTaggedSize + kApiIntSize;
+  static const int kStringResourceOffset = 1 * kApiTaggedSize + 2 * kApiIntSize;
+
+  static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize;
+  static const int kForeignAddressOffset = kApiTaggedSize;
+  static const int kJSObjectHeaderSize = 3 * kApiTaggedSize;
+  static const int kJSObjectHeaderSizeForEmbedderFields =
+      (kJSObjectHeaderSize + kApiSystemPointerSize - 1) &
+      -kApiSystemPointerSize;
+  static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
+  static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
+  static const int kEmbedderDataSlotSize =
+#ifdef V8_COMPRESS_POINTERS
+      2 *
+#endif
+      kApiSystemPointerSize;
+  static const int kNativeContextEmbedderDataOffset = 7 * kApiTaggedSize;
+  static const int kFullStringRepresentationMask = 0x0f;
+  static const int kStringEncodingMask = 0x8;
+  static const int kExternalTwoByteRepresentationTag = 0x02;
+  static const int kExternalOneByteRepresentationTag = 0x0a;
+
+  static const uint32_t kNumIsolateDataSlots = 4;
+
+  static const int kIsolateEmbedderDataOffset = 0;
+  static const int kExternalMemoryOffset =
+      kNumIsolateDataSlots * kApiTaggedSize;
+  static const int kExternalMemoryLimitOffset =
+      kExternalMemoryOffset + kApiInt64Size;
+  static const int kExternalMemoryAtLastMarkCompactOffset =
+      kExternalMemoryLimitOffset + kApiInt64Size;
+  static const int kIsolateRootsOffset =
+      kExternalMemoryAtLastMarkCompactOffset + kApiInt64Size;
+
+  static const int kUndefinedValueRootIndex = 4;
+  static const int kTheHoleValueRootIndex = 5;
+  static const int kNullValueRootIndex = 6;
+  static const int kTrueValueRootIndex = 7;
+  static const int kFalseValueRootIndex = 8;
+  static const int kEmptyStringRootIndex = 9;
+
+  static const int kNodeClassIdOffset = 1 * kApiTaggedSize;
+  static const int kNodeFlagsOffset = 1 * kApiTaggedSize + 3;
+  static const int kNodeStateMask = 0x7;
+  static const int kNodeStateIsWeakValue = 2;
+  static const int kNodeStateIsPendingValue = 3;
+  static const int kNodeStateIsNearDeathValue = 4;
+  static const int kNodeIsIndependentShift = 3;
+  static const int kNodeIsActiveShift = 4;
+
+  static const int kFirstNonstringType = 0x80;
+  static const int kOddballType = 0x83;
+  static const int kForeignType = 0x87;
+  static const int kJSSpecialApiObjectType = 0x410;
+  static const int kJSApiObjectType = 0x420;
+  static const int kJSObjectType = 0x421;
+
+  static const int kUndefinedOddballKind = 5;
+  static const int kNullOddballKind = 3;
+
+  // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an
+  // incremental GC once the external memory reaches this limit.
+  static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024;
+
+  V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
+  V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
+#ifdef V8_ENABLE_CHECKS
+    CheckInitializedImpl(isolate);
+#endif
+  }
+
+  V8_INLINE static bool HasHeapObjectTag(const internal::Address value) {
+    return (value & kHeapObjectTagMask) == static_cast<Address>(kHeapObjectTag);
+  }
+
+  V8_INLINE static int SmiValue(const internal::Address value) {
+    return PlatformSmiTagging::SmiToInt(value);
+  }
+
+  V8_INLINE static constexpr internal::Address IntToSmi(int value) {
+    return internal::IntToSmi(value);
+  }
+
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    return PlatformSmiTagging::IsValidSmi(value);
+  }
+
+  V8_INLINE static int GetInstanceType(const internal::Address obj) {
+    typedef internal::Address A;
+    A map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);
+    return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset);
+  }
+
+  V8_INLINE static int GetOddballKind(const internal::Address obj) {
+    return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset));
+  }
+
+  V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
+    int representation = (instance_type & kFullStringRepresentationMask);
+    return representation == kExternalTwoByteRepresentationTag;
+  }
+
+  V8_INLINE static uint8_t GetNodeFlag(internal::Address* obj, int shift) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    return *addr & static_cast<uint8_t>(1U << shift);
+  }
+
+  V8_INLINE static void UpdateNodeFlag(internal::Address* obj, bool value,
+                                       int shift) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    uint8_t mask = static_cast<uint8_t>(1U << shift);
+    *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
+  }
+
+  V8_INLINE static uint8_t GetNodeState(internal::Address* obj) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    return *addr & kNodeStateMask;
+  }
+
+  V8_INLINE static void UpdateNodeState(internal::Address* obj, uint8_t value) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
+  }
+
+  V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot,
+                                        void* data) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateEmbedderDataOffset +
+                             slot * kApiSystemPointerSize;
+    *reinterpret_cast<void**>(addr) = data;
+  }
+
+  V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
+                                         uint32_t slot) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateEmbedderDataOffset +
+                             slot * kApiSystemPointerSize;
+    return *reinterpret_cast<void* const*>(addr);
+  }
+
+  V8_INLINE static internal::Address* GetRoot(v8::Isolate* isolate, int index) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateRootsOffset +
+                             index * kApiSystemPointerSize;
+    return reinterpret_cast<internal::Address*>(addr);
+  }
+
+  template <typename T>
+  V8_INLINE static T ReadRawField(internal::Address heap_object_ptr,
+                                  int offset) {
+    internal::Address addr = heap_object_ptr + offset - kHeapObjectTag;
+    return *reinterpret_cast<const T*>(addr);
+  }
+
+  V8_INLINE static internal::Address ReadTaggedPointerField(
+      internal::Address heap_object_ptr, int offset) {
+#ifdef V8_COMPRESS_POINTERS
+    int32_t value = ReadRawField<int32_t>(heap_object_ptr, offset);
+    internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
+    return root + static_cast<internal::Address>(static_cast<intptr_t>(value));
+#else
+    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+#endif
+  }
+
+  V8_INLINE static internal::Address ReadTaggedSignedField(
+      internal::Address heap_object_ptr, int offset) {
+#ifdef V8_COMPRESS_POINTERS
+    int32_t value = ReadRawField<int32_t>(heap_object_ptr, offset);
+    return static_cast<internal::Address>(static_cast<intptr_t>(value));
+#else
+    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+#endif
+  }
+
+  V8_INLINE static internal::Address ReadTaggedAnyField(
+      internal::Address heap_object_ptr, int offset) {
+#ifdef V8_COMPRESS_POINTERS
+    int32_t value = ReadRawField<int32_t>(heap_object_ptr, offset);
+    internal::Address root_mask = static_cast<internal::Address>(
+        -static_cast<intptr_t>(value & kSmiTagMask));
+    internal::Address root_or_zero =
+        root_mask & GetRootFromOnHeapAddress(heap_object_ptr);
+    return root_or_zero +
+           static_cast<internal::Address>(static_cast<intptr_t>(value));
+#else
+    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+#endif
+  }
+
+#ifdef V8_COMPRESS_POINTERS
+  static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32;
+  static constexpr size_t kPtrComprIsolateRootBias =
+      kPtrComprHeapReservationSize / 2;
+  static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32;
+
+  V8_INLINE static internal::Address GetRootFromOnHeapAddress(
+      internal::Address addr) {
+    return (addr + kPtrComprIsolateRootBias) &
+           -static_cast<intptr_t>(kPtrComprIsolateRootAlignment);
+  }
+
+#else
+
+  template <typename T>
+  V8_INLINE static T ReadEmbedderData(const v8::Context* context, int index) {
+    typedef internal::Address A;
+    typedef internal::Internals I;
+    A ctx = *reinterpret_cast<const A*>(context);
+    A embedder_data =
+        I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
+    int value_offset =
+        I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
+    return I::ReadRawField<T>(embedder_data, value_offset);
+  }
+#endif  // V8_COMPRESS_POINTERS
+};
+
+// Only perform cast check for types derived from v8::Data since
+// other types do not implement the Cast method.
+template <bool PerformCheck>
+struct CastCheck {
+  template <class T>
+  static void Perform(T* data);
+};
+
+template <>
+template <class T>
+void CastCheck<true>::Perform(T* data) {
+  T::Cast(data);
+}
+
+template <>
+template <class T>
+void CastCheck<false>::Perform(T* data) {}
+
+template <class T>
+V8_INLINE void PerformCastCheck(T* data) {
+  CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
+}
+
+// {obj} must be the raw tagged pointer representation of a HeapObject
+// that's guaranteed to never be in ReadOnlySpace.
+V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_INTERNAL_H_