builtins-typed-array-gen.h 6.84 KB
Newer Older
1 2 3 4
// 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.

5 6
#ifndef V8_BUILTINS_BUILTINS_TYPED_ARRAY_GEN_H_
#define V8_BUILTINS_BUILTINS_TYPED_ARRAY_GEN_H_
7

8
#include "torque-generated/builtins-base-from-dsl-gen.h"
9 10 11 12

namespace v8 {
namespace internal {

13
class TypedArrayBuiltinsAssembler : public BaseBuiltinsFromDSLAssembler {
14 15
 public:
  explicit TypedArrayBuiltinsAssembler(compiler::CodeAssemblerState* state)
16
      : BaseBuiltinsFromDSLAssembler(state) {}
17 18 19 20 21 22 23 24 25 26

  TNode<JSTypedArray> SpeciesCreateByLength(TNode<Context> context,
                                            TNode<JSTypedArray> exemplar,
                                            TNode<Smi> len,
                                            const char* method_name);

 protected:
  void GenerateTypedArrayPrototypeGetter(Node* context, Node* receiver,
                                         const char* method_name,
                                         int object_offset);
27 28
  void GenerateTypedArrayPrototypeIterationMethod(TNode<Context> context,
                                                  TNode<Object> receiver,
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
                                                  const char* method_name,
                                                  IterationKind iteration_kind);

  void ConstructByLength(TNode<Context> context, TNode<JSTypedArray> holder,
                         TNode<Object> length, TNode<Smi> element_size);
  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 ConstructByArrayLike(TNode<Context> context, TNode<JSTypedArray> holder,
                            TNode<HeapObject> array_like,
                            TNode<Object> initial_length,
45 46
                            TNode<Smi> element_size,
                            TNode<JSReceiver> buffer_constructor);
47 48
  void ConstructByIterable(TNode<Context> context, TNode<JSTypedArray> holder,
                           TNode<JSReceiver> iterable,
49 50
                           TNode<JSReceiver> iterator_fn,
                           TNode<Smi> element_size);
51 52 53 54 55 56 57

  void SetupTypedArray(TNode<JSTypedArray> holder, TNode<Smi> length,
                       TNode<Number> byte_offset, TNode<Number> byte_length);
  void AttachBuffer(TNode<JSTypedArray> holder, TNode<JSArrayBuffer> buffer,
                    TNode<Map> map, TNode<Smi> length,
                    TNode<Number> byte_offset);

58 59 60 61
  void IterableToListSlowPath(TNode<Context> context, TNode<Object> iterable,
                              TNode<Object> iterator_fn,
                              Variable* created_list);

62 63 64 65 66 67 68 69 70
  TNode<Map> LoadMapForType(TNode<JSTypedArray> array);
  TNode<UintPtrT> CalculateExternalPointer(TNode<UintPtrT> backing_store,
                                           TNode<Number> byte_offset);
  Node* LoadDataPtr(Node* typed_array);
  TNode<BoolT> ByteLengthIsValid(TNode<Number> byte_length);

  // Returns true if kind is either UINT8_ELEMENTS or UINT8_CLAMPED_ELEMENTS.
  TNode<Word32T> IsUint8ElementsKind(TNode<Word32T> kind);

71 72 73
  // Returns true if kind is either BIGINT64_ELEMENTS or BIGUINT64_ELEMENTS.
  TNode<Word32T> IsBigInt64ElementsKind(TNode<Word32T> kind);

74 75 76
  // Returns the byte size of an element for a TypedArray elements kind.
  TNode<IntPtrT> GetTypedArrayElementSize(TNode<Word32T> elements_kind);

77 78 79 80 81
  TNode<JSArrayBuffer> LoadTypedArrayBuffer(TNode<JSTypedArray> typed_array) {
    return LoadObjectField<JSArrayBuffer>(typed_array,
                                          JSTypedArray::kBufferOffset);
  }

82 83 84 85 86 87 88 89 90 91 92 93 94
  TNode<Object> GetDefaultConstructor(TNode<Context> context,
                                      TNode<JSTypedArray> exemplar);

  TNode<Object> TypedArraySpeciesConstructor(TNode<Context> context,
                                             TNode<JSTypedArray> exemplar);

  TNode<JSTypedArray> SpeciesCreateByArrayBuffer(TNode<Context> context,
                                                 TNode<JSTypedArray> exemplar,
                                                 TNode<JSArrayBuffer> buffer,
                                                 TNode<Number> byte_offset,
                                                 TNode<Smi> len,
                                                 const char* method_name);

95 96 97 98
  TNode<JSTypedArray> CreateByLength(TNode<Context> context,
                                     TNode<Object> constructor, TNode<Smi> len,
                                     const char* method_name);

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
  TNode<JSArrayBuffer> GetBuffer(TNode<Context> context,
                                 TNode<JSTypedArray> array);

  TNode<JSTypedArray> ValidateTypedArray(TNode<Context> context,
                                         TNode<Object> obj,
                                         const char* method_name);

  // Fast path for setting a TypedArray (source) onto another TypedArray
  // (target) at an element offset.
  void SetTypedArraySource(TNode<Context> context, TNode<JSTypedArray> source,
                           TNode<JSTypedArray> target, TNode<IntPtrT> offset,
                           Label* call_runtime, Label* if_source_too_large);

  void SetJSArraySource(TNode<Context> context, TNode<JSArray> source,
                        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 CallCCopyFastNumberJSArrayElementsToTypedArray(
      TNode<Context> context, TNode<JSArray> source, TNode<JSTypedArray> dest,
      TNode<IntPtrT> source_length, TNode<IntPtrT> offset);

  void CallCCopyTypedArrayElementsToTypedArray(TNode<JSTypedArray> source,
                                               TNode<JSTypedArray> dest,
                                               TNode<IntPtrT> source_length,
                                               TNode<IntPtrT> offset);

128 129 130 131 132
  void CallCCopyTypedArrayElementsSlice(TNode<JSTypedArray> source,
                                        TNode<JSTypedArray> dest,
                                        TNode<IntPtrT> start,
                                        TNode<IntPtrT> end);

133 134 135 136 137 138 139 140 141
  typedef std::function<void(ElementsKind, int, int)> TypedArraySwitchCase;

  void DispatchTypedArrayByElementsKind(
      TNode<Word32T> elements_kind, const TypedArraySwitchCase& case_function);
};

}  // namespace internal
}  // namespace v8

142
#endif  // V8_BUILTINS_BUILTINS_TYPED_ARRAY_GEN_H_