src/v8/src/elements.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_ELEMENTS_H_
   6 #define V8_ELEMENTS_H_
   7
   8 #include "src/elements-kind.h"
   9 #include "src/heap/heap.h"
  10 #include "src/isolate.h"
  11 #include "src/objects.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16 // Abstract base class for handles that can operate on objects with differing
  17 // ElementsKinds.
  18 class ElementsAccessor {
  19  public:
  20   explicit ElementsAccessor(const char* name) : name_(name) { }
  21   virtual ~ElementsAccessor() { }
  22
  23   virtual ElementsKind kind() const = 0;
  24   const char* name() const { return name_; }
  25
  26   // Checks the elements of an object for consistency, asserting when a problem
  27   // is found.
  28   virtual void Validate(Handle<JSObject> obj) = 0;
  29
  30   // Returns true if a holder contains an element with the specified key
  31   // without iterating up the prototype chain.  The caller can optionally pass
  32   // in the backing store to use for the check, which must be compatible with
  33   // the ElementsKind of the ElementsAccessor. If backing_store is NULL, the
  34   // holder->elements() is used as the backing store.
  35   virtual bool HasElement(
  36       Handle<Object> receiver,
  37       Handle<JSObject> holder,
  38       uint32_t key,
  39       Handle<FixedArrayBase> backing_store) = 0;
  40
  41   inline bool HasElement(
  42       Handle<Object> receiver,
  43       Handle<JSObject> holder,
  44       uint32_t key) {
  45     return HasElement(receiver, holder, key, handle(holder->elements()));
  46   }
  47
  48   // Returns the element with the specified key or undefined if there is no such
  49   // element. This method doesn't iterate up the prototype chain.  The caller
  50   // can optionally pass in the backing store to use for the check, which must
  51   // be compatible with the ElementsKind of the ElementsAccessor. If
  52   // backing_store is NULL, the holder->elements() is used as the backing store.
  53   MUST_USE_RESULT virtual MaybeHandle<Object> Get(
  54       Handle<Object> receiver,
  55       Handle<JSObject> holder,
  56       uint32_t key,
  57       Handle<FixedArrayBase> backing_store) = 0;
  58
  59   MUST_USE_RESULT inline MaybeHandle<Object> Get(
  60       Handle<Object> receiver,
  61       Handle<JSObject> holder,
  62       uint32_t key) {
  63     return Get(receiver, holder, key, handle(holder->elements()));
  64   }
  65
  66   // Returns an element's attributes, or ABSENT if there is no such
  67   // element. This method doesn't iterate up the prototype chain.  The caller
  68   // can optionally pass in the backing store to use for the check, which must
  69   // be compatible with the ElementsKind of the ElementsAccessor. If
  70   // backing_store is NULL, the holder->elements() is used as the backing store.
  71   MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
  72       Handle<Object> receiver,
  73       Handle<JSObject> holder,
  74       uint32_t key,
  75       Handle<FixedArrayBase> backing_store) = 0;
  76
  77   MUST_USE_RESULT inline PropertyAttributes GetAttributes(
  78       Handle<Object> receiver,
  79       Handle<JSObject> holder,
  80       uint32_t key) {
  81     return GetAttributes(receiver, holder, key, handle(holder->elements()));
  82   }
  83
  84   // Returns an element's accessors, or NULL if the element does not exist or
  85   // is plain. This method doesn't iterate up the prototype chain.  The caller
  86   // can optionally pass in the backing store to use for the check, which must
  87   // be compatible with the ElementsKind of the ElementsAccessor. If
  88   // backing_store is NULL, the holder->elements() is used as the backing store.
  89   MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair(
  90       Handle<Object> receiver,
  91       Handle<JSObject> holder,
  92       uint32_t key,
  93       Handle<FixedArrayBase> backing_store) = 0;
  94
  95   MUST_USE_RESULT inline MaybeHandle<AccessorPair> GetAccessorPair(
  96       Handle<Object> receiver,
  97       Handle<JSObject> holder,
  98       uint32_t key) {
  99     return GetAccessorPair(receiver, holder, key, handle(holder->elements()));
 100   }
 101
 102   // Modifies the length data property as specified for JSArrays and resizes the
 103   // underlying backing store accordingly. The method honors the semantics of
 104   // changing array sizes as defined in EcmaScript 5.1 15.4.5.2, i.e. array that
 105   // have non-deletable elements can only be shrunk to the size of highest
 106   // element that is non-deletable.
 107   MUST_USE_RESULT virtual MaybeHandle<Object> SetLength(
 108       Handle<JSArray> holder,
 109       Handle<Object> new_length) = 0;
 110
 111   // Modifies both the length and capacity of a JSArray, resizing the underlying
 112   // backing store as necessary. This method does NOT honor the semantics of
 113   // EcmaScript 5.1 15.4.5.2, arrays can be shrunk beyond non-deletable
 114   // elements. This method should only be called for array expansion OR by
 115   // runtime JavaScript code that use InternalArrays and don't care about
 116   // EcmaScript 5.1 semantics.
 117   virtual void SetCapacityAndLength(
 118       Handle<JSArray> array,
 119       int capacity,
 120       int length) = 0;
 121
 122   // Deletes an element in an object, returning a new elements backing store.
 123   MUST_USE_RESULT virtual MaybeHandle<Object> Delete(
 124       Handle<JSObject> holder,
 125       uint32_t key,
 126       JSReceiver::DeleteMode mode) = 0;
 127
 128   // If kCopyToEnd is specified as the copy_size to CopyElements, it copies all
 129   // of elements from source after source_start to the destination array.
 130   static const int kCopyToEnd = -1;
 131   // If kCopyToEndAndInitializeToHole is specified as the copy_size to
 132   // CopyElements, it copies all of elements from source after source_start to
 133   // destination array, padding any remaining uninitialized elements in the
 134   // destination array with the hole.
 135   static const int kCopyToEndAndInitializeToHole = -2;
 136
 137   // Copy elements from one backing store to another. Typically, callers specify
 138   // the source JSObject or JSArray in source_holder. If the holder's backing
 139   // store is available, it can be passed in source and source_holder is
 140   // ignored.
 141   virtual void CopyElements(
 142       Handle<FixedArrayBase> source,
 143       uint32_t source_start,
 144       ElementsKind source_kind,
 145       Handle<FixedArrayBase> destination,
 146       uint32_t destination_start,
 147       int copy_size) = 0;
 148
 149   // TODO(ishell): Keeping |source_holder| parameter in a non-handlified form
 150   // helps avoiding ArrayConcat() builtin performance degradation.
 151   // Revisit this later.
 152   virtual void CopyElements(
 153       JSObject* source_holder,
 154       uint32_t source_start,
 155       ElementsKind source_kind,
 156       Handle<FixedArrayBase> destination,
 157       uint32_t destination_start,
 158       int copy_size) = 0;
 159
 160   inline void CopyElements(
 161       Handle<JSObject> from_holder,
 162       Handle<FixedArrayBase> to,
 163       ElementsKind from_kind) {
 164     CopyElements(
 165       *from_holder, 0, from_kind, to, 0, kCopyToEndAndInitializeToHole);
 166   }
 167
 168   MUST_USE_RESULT virtual MaybeHandle<FixedArray> AddElementsToFixedArray(
 169       Handle<Object> receiver,
 170       Handle<JSObject> holder,
 171       Handle<FixedArray> to,
 172       Handle<FixedArrayBase> from) = 0;
 173
 174   MUST_USE_RESULT inline MaybeHandle<FixedArray> AddElementsToFixedArray(
 175       Handle<Object> receiver,
 176       Handle<JSObject> holder,
 177       Handle<FixedArray> to) {
 178     return AddElementsToFixedArray(
 179         receiver, holder, to, handle(holder->elements()));
 180   }
 181
 182   // Returns a shared ElementsAccessor for the specified ElementsKind.
 183   static ElementsAccessor* ForKind(ElementsKind elements_kind) {
 184     DCHECK(static_cast<int>(elements_kind) < kElementsKindCount);
 185     return elements_accessors_[elements_kind];
 186   }
 187
 188   static ElementsAccessor* ForArray(Handle<FixedArrayBase> array);
 189
 190   static void InitializeOncePerProcess();
 191   static void TearDown();
 192
 193  protected:
 194   friend class SloppyArgumentsElementsAccessor;
 195
 196   virtual uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) = 0;
 197
 198   // Element handlers distinguish between indexes and keys when they manipulate
 199   // elements.  Indexes refer to elements in terms of their location in the
 200   // underlying storage's backing store representation, and are between 0 and
 201   // GetCapacity.  Keys refer to elements in terms of the value that would be
 202   // specified in JavaScript to access the element. In most implementations,
 203   // keys are equivalent to indexes, and GetKeyForIndex returns the same value
 204   // it is passed. In the NumberDictionary ElementsAccessor, GetKeyForIndex maps
 205   // the index to a key using the KeyAt method on the NumberDictionary.
 206   virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
 207                                   uint32_t index) = 0;
 208
 209  private:
 210   static ElementsAccessor** elements_accessors_;
 211   const char* name_;
 212
 213   DISALLOW_COPY_AND_ASSIGN(ElementsAccessor);
 214 };
 215
 216 void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t key,
 217                      bool allow_appending = false);
 218
 219 MUST_USE_RESULT MaybeHandle<Object> ArrayConstructInitializeElements(
 220     Handle<JSArray> array,
 221     Arguments* args);
 222
 223 } }  // namespace v8::internal
 224
 225 #endif  // V8_ELEMENTS_H_