feat: Updated V8 to latest version (8.9.0) (#102)

Author: NathanWalker

NativeScript/NativeScript-Prefix.pch

@@ -1,7 +1,7 @@
 #ifndef NativeScript_Prefix_pch
 #define NativeScript_Prefix_pch
 
-#define NATIVESCRIPT_VERSION "7.1.1"
+#define NATIVESCRIPT_VERSION "7.1.2-rc.0"
 
 #ifdef DEBUG
 #define SIZEOF_OFF_T 8

NativeScript/include/cppgc/common.h

@@ -0,0 +1,26 @@
+// Copyright 2020 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_CPPGC_COMMON_H_
+#define INCLUDE_CPPGC_COMMON_H_
+
+// TODO(chromium:1056170): Remove dependency on v8.
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+// Indicator for the stack state of the embedder.
+enum class EmbedderStackState {
+  kMayContainHeapPointers,
+  kNoHeapPointers,
+  kUnknown V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
+      kMayContainHeapPointers,
+  kNonEmpty V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
+      kMayContainHeapPointers,
+  kEmpty V8_ENUM_DEPRECATE_SOON("Use kNoHeapPointers") = kNoHeapPointers,
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_COMMON_H_

NativeScript/include/inspector/Debugger.h

@@ -31,6 +31,7 @@ namespace Paused {
 namespace ReasonEnum {
 V8_EXPORT extern const char* Ambiguous;
 V8_EXPORT extern const char* Assert;
+V8_EXPORT extern const char* CSPViolation;
 V8_EXPORT extern const char* DebugCommand;
 V8_EXPORT extern const char* DOM;
 V8_EXPORT extern const char* EventListener;

NativeScript/include/libplatform/libplatform.h

@@ -43,6 +43,27 @@ V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
         InProcessStackDumping::kDisabled,
     std::unique_ptr<v8::TracingController> tracing_controller = {});
 
+/**
+ * The same as NewDefaultPlatform but disables the worker thread pool.
+ * It must be used with the --single-threaded V8 flag.
+ */
+V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform>
+NewSingleThreadedDefaultPlatform(
+    IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
+    InProcessStackDumping in_process_stack_dumping =
+        InProcessStackDumping::kDisabled,
+    std::unique_ptr<v8::TracingController> tracing_controller = {});
+
+/**
+ * Returns a new instance of the default v8::JobHandle implementation.
+ *
+ * The job will be executed by spawning up to |num_worker_threads| many worker
+ * threads on the provided |platform| with the given |priority|.
+ */
+V8_PLATFORM_EXPORT std::unique_ptr<v8::JobHandle> NewDefaultJobHandle(
+    v8::Platform* platform, v8::TaskPriority priority,
+    std::unique_ptr<v8::JobTask> job_task, size_t num_worker_threads);
+
 /**
  * Pumps the message loop for the given isolate.
  *
@@ -79,6 +100,17 @@ V8_PLATFORM_EXPORT void SetTracingController(
     v8::Platform* platform,
     v8::platform::tracing::TracingController* tracing_controller);
 
+/**
+ * Notifies the given platform about the Isolate getting deleted soon. Has to be
+ * called for all Isolates which are deleted - unless we're shutting down the
+ * platform.
+ *
+ * The |platform| has to be created using |NewDefaultPlatform|.
+ *
+ */
+V8_PLATFORM_EXPORT void NotifyIsolateShutdown(v8::Platform* platform,
+                                              Isolate* isolate);
+
 }  // namespace platform
 }  // namespace v8
 

NativeScript/include/v8-inspector.h

@@ -181,6 +181,10 @@ class V8_EXPORT V8InspectorClient {
   virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
     return nullptr;
   }
+  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
+      v8::Local<v8::Context>, v8::Local<v8::Value>) {
+    return nullptr;
+  }
   virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>) {
     return false;
   }

NativeScript/include/v8-internal.h

@@ -120,6 +120,23 @@ constexpr bool HeapSandboxIsEnabled() {
 
 using ExternalPointer_t = Address;
 
+// If the heap sandbox is enabled, these tag values will be XORed with the
+// external pointers in the external pointer table to prevent use of pointers of
+// the wrong type.
+enum ExternalPointerTag : Address {
+  kExternalPointerNullTag = static_cast<Address>(0ULL),
+  kArrayBufferBackingStoreTag = static_cast<Address>(1ULL << 48),
+  kTypedArrayExternalPointerTag = static_cast<Address>(2ULL << 48),
+  kDataViewDataPointerTag = static_cast<Address>(3ULL << 48),
+  kExternalStringResourceTag = static_cast<Address>(4ULL << 48),
+  kExternalStringResourceDataTag = static_cast<Address>(5ULL << 48),
+  kForeignForeignAddressTag = static_cast<Address>(6ULL << 48),
+  kNativeContextMicrotaskQueueTag = static_cast<Address>(7ULL << 48),
+  // TODO(v8:10391, saelo): Currently has to be zero so that raw zero values are
+  // also nullptr
+  kEmbedderDataSlotPayloadTag = static_cast<Address>(0ULL << 48),
+};
+
 #ifdef V8_31BIT_SMIS_ON_64BIT_ARCH
 using PlatformSmiTagging = SmiTagging<kApiInt32Size>;
 #else
@@ -140,6 +157,20 @@ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
          kSmiTag;
 }
 
+// Converts encoded external pointer to address.
+V8_EXPORT Address DecodeExternalPointerImpl(const Isolate* isolate,
+                                            ExternalPointer_t pointer,
+                                            ExternalPointerTag tag);
+
+// {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);
+
+// Returns if we need to throw when an error occurs. This infers the language
+// mode based on the current context and the closure. This returns true if the
+// language mode is strict.
+V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
+
 /**
  * This class exports constants and functionality from within v8 that
  * is necessary to implement inline functions in the v8 api.  Don't
@@ -159,6 +190,9 @@ class Internals {
   static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
+#ifdef V8_HEAP_SANDBOX
+  static const int kEmbedderDataSlotRawPayloadOffset = kApiTaggedSize;
+#endif
   static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
   static const int kFullStringRepresentationMask = 0x0f;
   static const int kStringEncodingMask = 0x8;
@@ -169,21 +203,21 @@ class Internals {
 
   // IsolateData layout guarantees.
   static const int kIsolateEmbedderDataOffset = 0;
-  static const int kExternalMemoryOffset =
-      kNumIsolateDataSlots * kApiSystemPointerSize;
-  static const int kExternalMemoryLimitOffset =
-      kExternalMemoryOffset + kApiInt64Size;
-  static const int kExternalMemoryLowSinceMarkCompactOffset =
-      kExternalMemoryLimitOffset + kApiInt64Size;
   static const int kIsolateFastCCallCallerFpOffset =
-      kExternalMemoryLowSinceMarkCompactOffset + kApiInt64Size;
+      kNumIsolateDataSlots * kApiSystemPointerSize;
   static const int kIsolateFastCCallCallerPcOffset =
       kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;
   static const int kIsolateStackGuardOffset =
       kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
   static const int kIsolateRootsOffset =
       kIsolateStackGuardOffset + 7 * kApiSystemPointerSize;
 
+  static const int kExternalPointerTableBufferOffset = 0;
+  static const int kExternalPointerTableLengthOffset =
+      kExternalPointerTableBufferOffset + kApiSystemPointerSize;
+  static const int kExternalPointerTableCapacityOffset =
+      kExternalPointerTableLengthOffset + kApiInt32Size;
+
   static const int kUndefinedValueRootIndex = 4;
   static const int kTheHoleValueRootIndex = 5;
   static const int kNullValueRootIndex = 6;
@@ -339,16 +373,37 @@ class Internals {
 #endif
   }
 
+  V8_INLINE static internal::Isolate* GetIsolateForHeapSandbox(
+      internal::Address obj) {
+#ifdef V8_HEAP_SANDBOX
+    return internal::IsolateFromNeverReadOnlySpaceObject(obj);
+#else
+    // Not used in non-sandbox mode.
+    return nullptr;
+#endif
+  }
+
+  V8_INLINE static Address DecodeExternalPointer(
+      const Isolate* isolate, ExternalPointer_t encoded_pointer,
+      ExternalPointerTag tag) {
+#ifdef V8_HEAP_SANDBOX
+    return internal::DecodeExternalPointerImpl(isolate, encoded_pointer, tag);
+#else
+    return encoded_pointer;
+#endif
+  }
+
   V8_INLINE static internal::Address ReadExternalPointerField(
-      internal::Isolate* isolate, internal::Address heap_object_ptr,
-      int offset) {
-#ifdef V8_COMPRESS_POINTERS
-    internal::Address value = ReadRawField<Address>(heap_object_ptr, offset);
+      internal::Isolate* isolate, internal::Address heap_object_ptr, int offset,
+      ExternalPointerTag tag) {
+#ifdef V8_HEAP_SANDBOX
+    internal::ExternalPointer_t encoded_value =
+        ReadRawField<uint32_t>(heap_object_ptr, offset);
     // We currently have to treat zero as nullptr in embedder slots.
-    if (value) value = DecodeExternalPointer(isolate, value);
-    return value;
+    return encoded_value ? DecodeExternalPointer(isolate, encoded_value, tag)
+                         : 0;
 #else
-    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+    return ReadRawField<Address>(heap_object_ptr, offset);
 #endif
   }
 
@@ -357,10 +412,6 @@ class Internals {
   static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32;
   static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32;
 
-  // See v8:10391 for details about V8 heap sandbox.
-  static constexpr uint32_t kExternalPointerSalt =
-      0x7fffffff & ~static_cast<uint32_t>(kHeapObjectTagMask);
-
   V8_INLINE static internal::Address GetRootFromOnHeapAddress(
       internal::Address addr) {
     return addr & -static_cast<intptr_t>(kPtrComprIsolateRootAlignment);
@@ -372,14 +423,6 @@ class Internals {
     return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
   }
 
-  V8_INLINE static Address DecodeExternalPointer(
-      const Isolate* isolate, ExternalPointer_t encoded_pointer) {
-#ifndef V8_HEAP_SANDBOX
-    return encoded_pointer;
-#else
-    return encoded_pointer ^ kExternalPointerSalt;
-#endif
-  }
 #endif  // V8_COMPRESS_POINTERS
 };
 
@@ -403,18 +446,10 @@ 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);
+  CastCheck<std::is_base_of<Data, T>::value &&
+            !std::is_same<Data, std::remove_cv_t<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);
-
-// Returns if we need to throw when an error occurs. This infers the language
-// mode based on the current context and the closure. This returns true if the
-// language mode is strict.
-V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
-
 // A base class for backing stores, which is needed due to vagaries of
 // how static casts work with std::shared_ptr.
 class BackingStoreBase {};