elements.h 7.83 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4 5 6 7

#ifndef V8_ELEMENTS_H_
#define V8_ELEMENTS_H_

8
#include "src/elements-kind.h"
9
#include "src/heap/heap.h"
10
#include "src/isolate.h"
11
#include "src/objects.h"
12 13 14 15 16 17 18 19

namespace v8 {
namespace internal {

// Abstract base class for handles that can operate on objects with differing
// ElementsKinds.
class ElementsAccessor {
 public:
20
  explicit ElementsAccessor(const char* name) : name_(name) { }
21
  virtual ~ElementsAccessor() { }
22

23
  const char* name() const { return name_; }
24

25 26
  // Checks the elements of an object for consistency, asserting when a problem
  // is found.
27
  virtual void Validate(Handle<JSObject> obj) = 0;
28

29
  // Returns true if a holder contains an element with the specified index
30 31 32 33
  // without iterating up the prototype chain.  The caller can optionally pass
  // in the backing store to use for the check, which must be compatible with
  // the ElementsKind of the ElementsAccessor. If backing_store is NULL, the
  // holder->elements() is used as the backing store.
34 35 36 37 38
  virtual bool HasElement(Handle<JSObject> holder, uint32_t index,
                          Handle<FixedArrayBase> backing_store) = 0;

  inline bool HasElement(Handle<JSObject> holder, uint32_t index) {
    return HasElement(holder, index, handle(holder->elements()));
39
  }
40

41 42 43 44 45
  // Returns true if the backing store is compact in the given range
  virtual bool IsPacked(Handle<JSObject> holder,
                        Handle<FixedArrayBase> backing_store, uint32_t start,
                        uint32_t end) = 0;

46 47
  virtual Handle<Object> Get(Handle<FixedArrayBase> backing_store,
                             uint32_t entry) = 0;
48

49 50 51 52 53
  // Modifies the length data property as specified for JSArrays and resizes the
  // underlying backing store accordingly. The method honors the semantics of
  // changing array sizes as defined in EcmaScript 5.1 15.4.5.2, i.e. array that
  // have non-deletable elements can only be shrunk to the size of highest
  // element that is non-deletable.
54
  virtual void SetLength(Handle<JSArray> holder, uint32_t new_length) = 0;
55

56
  // Deletes an element in an object.
57
  virtual void Delete(Handle<JSObject> holder, uint32_t entry) = 0;
58

59 60 61 62 63 64 65 66 67
  // If kCopyToEnd is specified as the copy_size to CopyElements, it copies all
  // of elements from source after source_start to the destination array.
  static const int kCopyToEnd = -1;
  // If kCopyToEndAndInitializeToHole is specified as the copy_size to
  // CopyElements, it copies all of elements from source after source_start to
  // destination array, padding any remaining uninitialized elements in the
  // destination array with the hole.
  static const int kCopyToEndAndInitializeToHole = -2;

68 69 70 71
  // Copy elements from one backing store to another. Typically, callers specify
  // the source JSObject or JSArray in source_holder. If the holder's backing
  // store is available, it can be passed in source and source_holder is
  // ignored.
72
  virtual void CopyElements(
73 74 75 76 77 78 79
      Handle<FixedArrayBase> source,
      uint32_t source_start,
      ElementsKind source_kind,
      Handle<FixedArrayBase> destination,
      uint32_t destination_start,
      int copy_size) = 0;

80 81 82 83
  // NOTE: this method violates the handlified function signature convention:
  // raw pointer parameter |source_holder| in the function that allocates.
  // This is done intentionally to avoid ArrayConcat() builtin performance
  // degradation.
84 85
  virtual void CopyElements(
      JSObject* source_holder,
86 87 88 89
      uint32_t source_start,
      ElementsKind source_kind,
      Handle<FixedArrayBase> destination,
      uint32_t destination_start,
90
      int copy_size) = 0;
91

92
  inline void CopyElements(
93 94
      Handle<JSObject> from_holder,
      Handle<FixedArrayBase> to,
95 96 97
      ElementsKind from_kind) {
    CopyElements(
      *from_holder, 0, from_kind, to, 0, kCopyToEndAndInitializeToHole);
98 99
  }

100 101 102
  virtual void GrowCapacityAndConvert(Handle<JSObject> object,
                                      uint32_t capacity) = 0;

103 104
  virtual void AddElementsToKeyAccumulator(Handle<JSObject> receiver,
                                           KeyAccumulator* accumulator,
105
                                           KeyFilter filter) = 0;
106

107
  // Returns a shared ElementsAccessor for the specified ElementsKind.
108
  static ElementsAccessor* ForKind(ElementsKind elements_kind) {
109
    DCHECK(static_cast<int>(elements_kind) < kElementsKindCount);
110 111 112
    return elements_accessors_[elements_kind];
  }

113
  static ElementsAccessor* ForArray(Handle<FixedArrayBase> array);
114

115
  static void InitializeOncePerProcess();
116
  static void TearDown();
117

118
  virtual void Set(FixedArrayBase* backing_store, uint32_t entry,
119
                   Object* value) = 0;
120

121
  virtual void Reconfigure(Handle<JSObject> object,
122
                           Handle<FixedArrayBase> backing_store, uint32_t entry,
123 124
                           Handle<Object> value,
                           PropertyAttributes attributes) = 0;
125

126
  virtual void Add(Handle<JSObject> object, uint32_t index,
127 128
                   Handle<Object> value, PropertyAttributes attributes,
                   uint32_t new_capacity) = 0;
129

130 131 132
  static Handle<JSArray> Concat(Isolate* isolate, Arguments* args,
                                uint32_t concat_size);

133
  virtual uint32_t Push(Handle<JSArray> receiver,
134 135
                        Handle<FixedArrayBase> backing_store, Arguments* args,
                        uint32_t push_size) = 0;
136

137 138 139 140
  virtual uint32_t Unshift(Handle<JSArray> receiver,
                           Handle<FixedArrayBase> backing_store,
                           Arguments* args, uint32_t unshift_size) = 0;

141 142 143 144
  virtual Handle<JSArray> Slice(Handle<JSObject> receiver,
                                Handle<FixedArrayBase> backing_store,
                                uint32_t start, uint32_t end) = 0;

145 146 147
  virtual Handle<JSArray> Splice(Handle<JSArray> receiver,
                                 Handle<FixedArrayBase> backing_store,
                                 uint32_t start, uint32_t delete_count,
148
                                 Arguments* args, uint32_t add_count) = 0;
149

cbruni's avatar
cbruni committed
150 151 152
  virtual Handle<Object> Pop(Handle<JSArray> receiver,
                             Handle<FixedArrayBase> backing_store) = 0;

153 154 155
  virtual Handle<Object> Shift(Handle<JSArray> receiver,
                               Handle<FixedArrayBase> backing_store) = 0;

156
 protected:
157
  friend class LookupIterator;
158

159 160 161 162
  static ElementsAccessor* ForArray(FixedArrayBase* array);

  virtual uint32_t GetCapacity(JSObject* holder,
                               FixedArrayBase* backing_store) = 0;
163

164 165 166 167 168 169 170 171 172 173 174
  // Element handlers distinguish between entries and indices when they
  // manipulate elements. Entries refer to elements in terms of their location
  // in the underlying storage's backing store representation, and are between 0
  // and GetCapacity. Indices refer to elements in terms of the value that would
  // be specified in JavaScript to access the element. In most implementations,
  // indices are equivalent to entries. In the NumberDictionary
  // ElementsAccessor, entries are mapped to an index using the KeyAt method on
  // the NumberDictionary.
  virtual uint32_t GetEntryForIndex(JSObject* holder,
                                    FixedArrayBase* backing_store,
                                    uint32_t index) = 0;
175
  virtual PropertyDetails GetDetails(FixedArrayBase* backing_store,
176
                                     uint32_t entry) = 0;
177

178 179
 private:
  static ElementsAccessor** elements_accessors_;
180
  const char* name_;
181 182 183 184

  DISALLOW_COPY_AND_ASSIGN(ElementsAccessor);
};

185
void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t index,
186
                     bool allow_appending = false);
187

188 189 190
MUST_USE_RESULT MaybeHandle<Object> ArrayConstructInitializeElements(
    Handle<JSArray> array,
    Arguments* args);
191

192 193
}  // namespace internal
}  // namespace v8
194 195

#endif  // V8_ELEMENTS_H_