@encharm/cws 4.4.0 → 4.5.1

package/src/headers/{18 → 22}/v8-fast-api-calls.h

@@ -240,19 +240,22 @@ class CTypeInfo {
   enum class Type : uint8_t {
     kVoid,
     kBool,
+    kUint8,
     kInt32,
     kUint32,
     kInt64,
     kUint64,
     kFloat32,
     kFloat64,
+    kPointer,
     kV8Value,
+    kSeqOneByteString,
     kApiObject,  // This will be deprecated once all users have
                  // migrated from v8::ApiObject to v8::Local<v8::Value>.
     kAny,        // This is added to enable untyped representation of fast
                  // call arguments for test purposes. It can represent any of
-                 // the other types stored in the same memory as a union (see
-                 // the AnyCType struct declared below). This allows for
+                 // the other types stored in the same memory as a union
+                 // (see AnyCType declared below). This allows for
                  // uniform passing of arguments w.r.t. their location
                  // (in a register or on the stack), independent of their
                  // actual type. It's currently used by the arm64 simulator
@@ -302,8 +305,9 @@ class CTypeInfo {
   constexpr Flags GetFlags() const { return flags_; }
 
   static constexpr bool IsIntegralType(Type type) {
-    return type == Type::kInt32 || type == Type::kUint32 ||
-           type == Type::kInt64 || type == Type::kUint64;
+    return type == Type::kUint8 || type == Type::kInt32 ||
+           type == Type::kUint32 || type == Type::kInt64 ||
+           type == Type::kUint64;
   }
 
   static constexpr bool IsFloatingPointType(Type type) {
@@ -340,7 +344,8 @@ struct FastApiTypedArray : public FastApiTypedArrayBase {
     ValidateIndex(index);
 #endif  // DEBUG
     T tmp;
-    memcpy(&tmp, reinterpret_cast<T*>(data_) + index, sizeof(T));
+    memcpy(&tmp, static_cast<void*>(reinterpret_cast<T*>(data_) + index),
+           sizeof(T));
     return tmp;
   }
 
@@ -377,15 +382,26 @@ struct FastApiArrayBuffer {
   size_t byte_length;
 };
 
+struct FastOneByteString {
+  const char* data;
+  uint32_t length;
+};
+
 class V8_EXPORT CFunctionInfo {
  public:
+  enum class Int64Representation : uint8_t {
+    kNumber = 0,  // Use numbers to represent 64 bit integers.
+    kBigInt = 1,  // Use BigInts to represent 64 bit integers.
+  };
+
   // Construct a struct to hold a CFunction's type information.
   // |return_info| describes the function's return type.
   // |arg_info| is an array of |arg_count| CTypeInfos describing the
   //   arguments. Only the last argument may be of the special type
   //   CTypeInfo::kCallbackOptionsType.
   CFunctionInfo(const CTypeInfo& return_info, unsigned int arg_count,
-                const CTypeInfo* arg_info);
+                const CTypeInfo* arg_info,
+                Int64Representation repr = Int64Representation::kNumber);
 
   const CTypeInfo& ReturnInfo() const { return return_info_; }
 
@@ -395,6 +411,8 @@ class V8_EXPORT CFunctionInfo {
     return HasOptions() ? arg_count_ - 1 : arg_count_;
   }
 
+  Int64Representation GetInt64Representation() const { return repr_; }
+
   // |index| must be less than ArgumentCount().
   //  Note: if the last argument passed on construction of CFunctionInfo
   //  has type CTypeInfo::kCallbackOptionsType, it is not included in
@@ -409,6 +427,7 @@ class V8_EXPORT CFunctionInfo {
 
  private:
   const CTypeInfo return_info_;
+  const Int64Representation repr_;
   const unsigned int arg_count_;
   const CTypeInfo* arg_info_;
 };
@@ -416,32 +435,43 @@ class V8_EXPORT CFunctionInfo {
 struct FastApiCallbackOptions;
 
 // Provided for testing.
-struct AnyCType {
+union V8_TRIVIAL_ABI AnyCType {
   AnyCType() : int64_value(0) {}
 
-  union {
-    bool bool_value;
-    int32_t int32_value;
-    uint32_t uint32_value;
-    int64_t int64_value;
-    uint64_t uint64_value;
-    float float_value;
-    double double_value;
-    Local<Object> object_value;
-    Local<Array> sequence_value;
-    const FastApiTypedArray<int32_t>* int32_ta_value;
-    const FastApiTypedArray<uint32_t>* uint32_ta_value;
-    const FastApiTypedArray<int64_t>* int64_ta_value;
-    const FastApiTypedArray<uint64_t>* uint64_ta_value;
-    const FastApiTypedArray<float>* float_ta_value;
-    const FastApiTypedArray<double>* double_ta_value;
-    FastApiCallbackOptions* options_value;
-  };
+#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
+  // In this case, Local<T> is not trivially copyable and the implicit
+  // copy constructor and copy assignment for the union are deleted.
+  AnyCType(const AnyCType& other) : int64_value(other.int64_value) {}
+  AnyCType& operator=(const AnyCType& other) {
+    int64_value = other.int64_value;
+    return *this;
+  }
+#endif
+
+  bool bool_value;
+  int32_t int32_value;
+  uint32_t uint32_value;
+  int64_t int64_value;
+  uint64_t uint64_value;
+  float float_value;
+  double double_value;
+  void* pointer_value;
+  Local<Object> object_value;
+  Local<Array> sequence_value;
+  const FastApiTypedArray<uint8_t>* uint8_ta_value;
+  const FastApiTypedArray<int32_t>* int32_ta_value;
+  const FastApiTypedArray<uint32_t>* uint32_ta_value;
+  const FastApiTypedArray<int64_t>* int64_ta_value;
+  const FastApiTypedArray<uint64_t>* uint64_ta_value;
+  const FastApiTypedArray<float>* float_ta_value;
+  const FastApiTypedArray<double>* double_ta_value;
+  const FastOneByteString* string_value;
+  FastApiCallbackOptions* options_value;
 };
 
 static_assert(
     sizeof(AnyCType) == 8,
-    "The AnyCType struct should have size == 64 bits, as this is assumed "
+    "The union AnyCType should have size == 64 bits, as this is assumed "
     "by EffectControlLinearizer.");
 
 class V8_EXPORT CFunction {
@@ -457,6 +487,9 @@ class V8_EXPORT CFunction {
   unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
 
   const void* GetAddress() const { return address_; }
+  CFunctionInfo::Int64Representation GetInt64Representation() const {
+    return type_info_->GetInt64Representation();
+  }
   const CFunctionInfo* GetTypeInfo() const { return type_info_; }
 
   enum class OverloadResolution { kImpossible, kAtRuntime, kAtCompileTime };
@@ -544,7 +577,7 @@ struct FastApiCallbackOptions {
    * returned instance may be filled with mock data.
    */
   static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
-    return {false, {0}};
+    return {false, {0}, nullptr};
   }
 
   /**
@@ -566,8 +599,13 @@ struct FastApiCallbackOptions {
    */
   union {
     uintptr_t data_ptr;
-    v8::Value data;
+    v8::Local<v8::Value> data;
   };
+
+  /**
+   * When called from WebAssembly, a view of the calling module's memory.
+   */
+  FastApiTypedArray<uint8_t>* const wasm_memory;
 };
 
 namespace internal {
@@ -581,7 +619,8 @@ struct count<T, T, Args...>
 template <typename T, typename U, typename... Args>
 struct count<T, U, Args...> : count<T, Args...> {};
 
-template <typename RetBuilder, typename... ArgBuilders>
+template <CFunctionInfo::Int64Representation Representation,
+          typename RetBuilder, typename... ArgBuilders>
 class CFunctionInfoImpl : public CFunctionInfo {
   static constexpr int kOptionsArgCount =
       count<FastApiCallbackOptions&, ArgBuilders...>();
@@ -596,17 +635,20 @@ class CFunctionInfoImpl : public CFunctionInfo {
  public:
   constexpr CFunctionInfoImpl()
       : CFunctionInfo(RetBuilder::Build(), sizeof...(ArgBuilders),
-                      arg_info_storage_),
+                      arg_info_storage_, Representation),
         arg_info_storage_{ArgBuilders::Build()...} {
     constexpr CTypeInfo::Type kReturnType = RetBuilder::Build().GetType();
     static_assert(kReturnType == CTypeInfo::Type::kVoid ||
                       kReturnType == CTypeInfo::Type::kBool ||
                       kReturnType == CTypeInfo::Type::kInt32 ||
                       kReturnType == CTypeInfo::Type::kUint32 ||
+                      kReturnType == CTypeInfo::Type::kInt64 ||
+                      kReturnType == CTypeInfo::Type::kUint64 ||
                       kReturnType == CTypeInfo::Type::kFloat32 ||
                       kReturnType == CTypeInfo::Type::kFloat64 ||
+                      kReturnType == CTypeInfo::Type::kPointer ||
                       kReturnType == CTypeInfo::Type::kAny,
-                  "64-bit int and api object values are not currently "
+                  "String and api object values are not currently "
                   "supported return types.");
   }
 
@@ -643,12 +685,14 @@ struct CTypeInfoTraits {};
 
 #define PRIMITIVE_C_TYPES(V) \
   V(bool, kBool)             \
+  V(uint8_t, kUint8)         \
   V(int32_t, kInt32)         \
   V(uint32_t, kUint32)       \
   V(int64_t, kInt64)         \
   V(uint64_t, kUint64)       \
   V(float, kFloat32)         \
-  V(double, kFloat64)
+  V(double, kFloat64)        \
+  V(void*, kPointer)
 
 // Same as above, but includes deprecated types for compatibility.
 #define ALL_C_TYPES(V)               \
@@ -682,6 +726,7 @@ PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
   };
 
 #define TYPED_ARRAY_C_TYPES(V) \
+  V(uint8_t, kUint8)           \
   V(int32_t, kInt32)           \
   V(uint32_t, kUint32)         \
   V(int64_t, kInt64)           \
@@ -725,6 +770,18 @@ struct TypeInfoHelper<FastApiCallbackOptions&> {
   }
 };
 
+template <>
+struct TypeInfoHelper<const FastOneByteString&> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
+
+  static constexpr CTypeInfo::Type Type() {
+    return CTypeInfo::Type::kSeqOneByteString;
+  }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kScalar;
+  }
+};
+
 #define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
   static_assert(((COND) == 0) || (ASSERTION), MSG)
 
@@ -802,8 +859,21 @@ class CFunctionBuilderWithFunction {
         std::make_index_sequence<sizeof...(ArgBuilders)>());
   }
 
+  // Provided for testing purposes.
+  template <typename Ret, typename... Args>
+  auto Patch(Ret (*patching_func)(Args...)) {
+    static_assert(
+        sizeof...(Args) == sizeof...(ArgBuilders),
+        "The patching function must have the same number of arguments.");
+    fn_ = reinterpret_cast<void*>(patching_func);
+    return *this;
+  }
+
+  template <CFunctionInfo::Int64Representation Representation =
+                CFunctionInfo::Int64Representation::kNumber>
   auto Build() {
-    static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
+    static CFunctionInfoImpl<Representation, RetBuilder, ArgBuilders...>
+        instance;
     return CFunction(fn_, &instance);
   }
 
@@ -881,31 +951,6 @@ static constexpr CTypeInfo kTypeInfoFloat64 =
  * to the requested destination type, is considered unsupported. The operation
  * returns true on success. `type_info` will be used for conversions.
  */
-template <const CTypeInfo* type_info, typename T>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-bool V8_EXPORT V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
-                                      uint32_t max_length);
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoInt32, int32_t>(
-        Local<Array> src, int32_t* dst, uint32_t max_length) {
-  return false;
-}
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoFloat64, double>(
-        Local<Array> src, double* dst, uint32_t max_length) {
-  return false;
-}
-
 template <CTypeInfo::Identifier type_info_id, typename T>
 bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer(
     Local<Array> src, T* dst, uint32_t max_length);

package/src/headers/14/aliased_buffer.h

@@ -1,263 +0,0 @@
-#ifndef SRC_ALIASED_BUFFER_H_
-#define SRC_ALIASED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cinttypes>
-#include "util-inl.h"
-#include "v8.h"
-
-namespace node {
-
-/**
- * Do not use this class directly when creating instances of it - use the
- * Aliased*Array defined at the end of this file instead.
- *
- * This class encapsulates the technique of having a native buffer mapped to
- * a JS object. Writes to the native buffer can happen efficiently without
- * going through JS, and the data is then available to user's via the exposed
- * JS object.
- *
- * While this technique is computationally efficient, it is effectively a
- * write to JS program state w/out going through the standard
- * (monitored) API. Thus any VM capabilities to detect the modification are
- * circumvented.
- *
- * The encapsulation herein provides a placeholder where such writes can be
- * observed. Any notification APIs will be left as a future exercise.
- */
-template <class NativeT,
-          class V8T,
-          // SFINAE NativeT to be scalar
-          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
-class AliasedBufferBase {
- public:
-  AliasedBufferBase(v8::Isolate* isolate, const size_t count)
-      : isolate_(isolate), count_(count), byte_offset_(0) {
-    CHECK_GT(count, 0);
-    const v8::HandleScope handle_scope(isolate_);
-    const size_t size_in_bytes =
-        MultiplyWithOverflowCheck(sizeof(NativeT), count);
-
-    // allocate v8 ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, size_in_bytes);
-    buffer_ = static_cast<NativeT*>(ab->GetBackingStore()->Data());
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  /**
-   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
-   * The two will share a v8::ArrayBuffer instance &
-   * a native buffer, but will each read/write to different sections of the
-   * native buffer.
-   *
-   *  Note that byte_offset must by aligned by sizeof(NativeT).
-   */
-  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
-  AliasedBufferBase(
-      v8::Isolate* isolate,
-      const size_t byte_offset,
-      const size_t count,
-      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer)
-      : isolate_(isolate), count_(count), byte_offset_(byte_offset) {
-    const v8::HandleScope handle_scope(isolate_);
-
-    v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
-
-    // validate that the byte_offset is aligned with sizeof(NativeT)
-    CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
-    // validate this fits inside the backing buffer
-    CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
-             ab->ByteLength() - byte_offset);
-
-    buffer_ = reinterpret_cast<NativeT*>(
-        const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
-
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  AliasedBufferBase(const AliasedBufferBase& that)
-      : isolate_(that.isolate_),
-        count_(that.count_),
-        byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_) {
-    js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
-  }
-
-  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
-    this->~AliasedBufferBase();
-    isolate_ = that.isolate_;
-    count_ = that.count_;
-    byte_offset_ = that.byte_offset_;
-    buffer_ = that.buffer_;
-
-    js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
-
-    that.buffer_ = nullptr;
-    that.js_array_.Reset();
-    return *this;
-  }
-
-  /**
-   * Helper class that is returned from operator[] to support assignment into
-   * a specified location.
-   */
-  class Reference {
-   public:
-    Reference(AliasedBufferBase<NativeT, V8T>* aliased_buffer, size_t index)
-        : aliased_buffer_(aliased_buffer), index_(index) {}
-
-    Reference(const Reference& that)
-        : aliased_buffer_(that.aliased_buffer_),
-          index_(that.index_) {
-    }
-
-    inline Reference& operator=(const NativeT& val) {
-      aliased_buffer_->SetValue(index_, val);
-      return *this;
-    }
-
-    inline Reference& operator=(const Reference& val) {
-      return *this = static_cast<NativeT>(val);
-    }
-
-    operator NativeT() const {
-      return aliased_buffer_->GetValue(index_);
-    }
-
-    inline Reference& operator+=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current + val);
-      return *this;
-    }
-
-    inline Reference& operator+=(const Reference& val) {
-      return this->operator+=(static_cast<NativeT>(val));
-    }
-
-    inline Reference& operator-=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current - val);
-      return *this;
-    }
-
-   private:
-    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;
-    size_t index_;
-  };
-
-  /**
-   *  Get the underlying v8 TypedArray overlayed on top of the native buffer
-   */
-  v8::Local<V8T> GetJSArray() const {
-    return js_array_.Get(isolate_);
-  }
-
-  /**
-  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
-  *  overlaying the native buffer
-  */
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return GetJSArray()->Buffer();
-  }
-
-  /**
-   *  Get the underlying native buffer. Note that all reads/writes should occur
-   *  through the GetValue/SetValue/operator[] methods
-   */
-  inline const NativeT* GetNativeBuffer() const {
-    return buffer_;
-  }
-
-  /**
-   *  Synonym for GetBuffer()
-   */
-  inline const NativeT* operator * () const {
-    return GetNativeBuffer();
-  }
-
-  /**
-   *  Set position index to given value.
-   */
-  inline void SetValue(const size_t index, NativeT value) {
-    DCHECK_LT(index, count_);
-    buffer_[index] = value;
-  }
-
-  /**
-   *  Get value at position index
-   */
-  inline const NativeT GetValue(const size_t index) const {
-    DCHECK_LT(index, count_);
-    return buffer_[index];
-  }
-
-  /**
-   *  Effectively, a synonym for GetValue/SetValue
-   */
-  Reference operator[](size_t index) {
-    return Reference(this, index);
-  }
-
-  NativeT operator[](size_t index) const {
-    return GetValue(index);
-  }
-
-  size_t Length() const {
-    return count_;
-  }
-
-  // Should only be used to extend the array.
-  // Should only be used on an owning array, not one created as a sub array of
-  // an owning `AliasedBufferBase`.
-  void reserve(size_t new_capacity) {
-    DCHECK_GE(new_capacity, count_);
-    DCHECK_EQ(byte_offset_, 0);
-    const v8::HandleScope handle_scope(isolate_);
-
-    const size_t old_size_in_bytes = sizeof(NativeT) * count_;
-    const size_t new_size_in_bytes = MultiplyWithOverflowCheck(sizeof(NativeT),
-                                                              new_capacity);
-
-    // allocate v8 new ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, new_size_in_bytes);
-
-    // allocate new native buffer
-    NativeT* new_buffer = static_cast<NativeT*>(ab->GetBackingStore()->Data());
-    // copy old content
-    memcpy(new_buffer, buffer_, old_size_in_bytes);
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
-
-    // move over old v8 TypedArray
-    js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
-
-    buffer_ = new_buffer;
-    count_ = new_capacity;
-  }
-
- private:
-  v8::Isolate* isolate_;
-  size_t count_;
-  size_t byte_offset_;
-  NativeT* buffer_;
-  v8::Global<V8T> js_array_;
-};
-
-typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
-typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
-typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
-typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_BUFFER_H_