deps: update V8 to 7.4.288.13

PR-URL: https://github.com/nodejs/node/pull/26685
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>

1 files changed, 24 insertions, 27 deletions

diff --git a/deps/v8/src/builtins/builtins-typed-array-gen.h b/deps/v8/src/builtins/builtins-typed-array-gen.h
index a82b32c25c..ab0ee6016d 100644
--- a/deps/v8/src/builtins/builtins-typed-array-gen.h
+++ b/deps/v8/src/builtins/builtins-typed-array-gen.h
@@ -6,12 +6,15 @@
 #define V8_BUILTINS_BUILTINS_TYPED_ARRAY_GEN_H_
 
 #include "src/code-stub-assembler.h"
+#include "torque-generated/builtins-typed-array-from-dsl-gen.h"
 
 namespace v8 {
 namespace internal {
 
 class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
  public:
+  using ElementsInfo =
+      TypedArrayBuiltinsFromDSLAssembler::TypedArrayElementsInfo;
   explicit TypedArrayBuiltinsAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
@@ -21,40 +24,31 @@ class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
                                               TNode<JSTypedArray> exemplar,
                                               TArgs... args);
 
-  TNode<JSTypedArray> TypedArraySpeciesCreateByLength(
-      TNode<Context> context, TNode<JSTypedArray> exemplar, TNode<Smi> len,
-      const char* method_name);
-
   void GenerateTypedArrayPrototypeIterationMethod(TNode<Context> context,
                                                   TNode<Object> receiver,
                                                   const char* method_name,
                                                   IterationKind iteration_kind);
 
-  void ConstructByArrayBuffer(TNode<Context> context,
-                              TNode<JSTypedArray> holder,
-                              TNode<JSArrayBuffer> buffer,
-                              TNode<Object> byte_offset, TNode<Object> length,
-                              TNode<Smi> element_size);
-  void ConstructByTypedArray(TNode<Context> context, TNode<JSTypedArray> holder,
-                             TNode<JSTypedArray> typed_array,
-                             TNode<Smi> element_size);
-  void ConstructByIterable(TNode<Context> context, TNode<JSTypedArray> holder,
-                           TNode<JSReceiver> iterable,
-                           TNode<JSReceiver> iterator_fn,
-                           TNode<Smi> element_size);
-
   void SetupTypedArray(TNode<JSTypedArray> holder, TNode<Smi> length,
                        TNode<UintPtrT> byte_offset,
                        TNode<UintPtrT> byte_length);
   void AttachBuffer(TNode<JSTypedArray> holder, TNode<JSArrayBuffer> buffer,
                     TNode<Map> map, TNode<Smi> length,
-                    TNode<Number> byte_offset);
+                    TNode<UintPtrT> byte_offset);
+
+  TNode<JSArrayBuffer> AllocateEmptyOnHeapBuffer(TNode<Context> context,
+                                                 TNode<JSTypedArray> holder,
+                                                 TNode<UintPtrT> byte_length);
+
+  TNode<FixedTypedArrayBase> AllocateOnHeapElements(TNode<Map> map,
+                                                    TNode<IntPtrT> byte_length,
+                                                    TNode<Number> length);
 
   TNode<Map> LoadMapForType(TNode<JSTypedArray> array);
+  TNode<BoolT> IsMockArrayBufferAllocatorFlag();
   TNode<UintPtrT> CalculateExternalPointer(TNode<UintPtrT> backing_store,
-                                           TNode<Number> byte_offset);
-  Node* LoadDataPtr(Node* typed_array);
-  TNode<BoolT> ByteLengthIsValid(TNode<Number> byte_length);
+                                           TNode<UintPtrT> byte_offset);
+  TNode<RawPtrT> LoadDataPtr(TNode<JSTypedArray> typed_array);
 
   // Returns true if kind is either UINT8_ELEMENTS or UINT8_CLAMPED_ELEMENTS.
   TNode<Word32T> IsUint8ElementsKind(TNode<Word32T> kind);
@@ -65,10 +59,8 @@ class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
   // Returns the byte size of an element for a TypedArray elements kind.
   TNode<IntPtrT> GetTypedArrayElementSize(TNode<Word32T> elements_kind);
 
-  TNode<JSArrayBuffer> LoadTypedArrayBuffer(TNode<JSTypedArray> typed_array) {
-    return LoadObjectField<JSArrayBuffer>(typed_array,
-                                          JSTypedArray::kBufferOffset);
-  }
+  // Returns information (byte size and map) about a TypedArray's elements.
+  ElementsInfo GetTypedArrayElementsInfo(TNode<JSTypedArray> typed_array);
 
   TNode<JSFunction> GetDefaultConstructor(TNode<Context> context,
                                           TNode<JSTypedArray> exemplar);
@@ -99,12 +91,15 @@ class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
                         TNode<JSTypedArray> target, TNode<IntPtrT> offset,
                         Label* call_runtime, Label* if_source_too_large);
 
-  void CallCMemmove(TNode<IntPtrT> dest_ptr, TNode<IntPtrT> src_ptr,
-                    TNode<IntPtrT> byte_length);
+  void CallCMemmove(TNode<RawPtrT> dest_ptr, TNode<RawPtrT> src_ptr,
+                    TNode<UintPtrT> byte_length);
 
   void CallCMemcpy(TNode<RawPtrT> dest_ptr, TNode<RawPtrT> src_ptr,
                    TNode<UintPtrT> byte_length);
 
+  void CallCMemset(TNode<RawPtrT> dest_ptr, TNode<IntPtrT> value,
+                   TNode<UintPtrT> length);
+
   void CallCCopyFastNumberJSArrayElementsToTypedArray(
       TNode<Context> context, TNode<JSArray> source, TNode<JSTypedArray> dest,
       TNode<IntPtrT> source_length, TNode<IntPtrT> offset);
@@ -123,6 +118,8 @@ class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
 
   void DispatchTypedArrayByElementsKind(
       TNode<Word32T> elements_kind, const TypedArraySwitchCase& case_function);
+
+  TNode<BoolT> IsSharedArrayBuffer(TNode<JSArrayBuffer> buffer);
 };
 
 }  // namespace internal