Cleanup typed array setters, the property is guaranteed to be there.

BUG=v8:4137
LOG=n

Review URL: https://codereview.chromium.org/1180753005

Cr-Commit-Position: refs/heads/master@{#29129}

diff --git a/src/elements.cc b/src/elements.cc
index 128ba95..20d4264 100644 (file)
--- a/src/elements.cc
+++ b/src/elements.cc
@@ -613,18 +613,14 @@ class ElementsAccessorBase : public ElementsAccessor {
     }
   }
 
-  virtual void Set(Handle<JSObject> holder, uint32_t key,
-                   Handle<FixedArrayBase> backing_store,
+  virtual void Set(Handle<FixedArrayBase> backing_store, uint32_t key,
                    Handle<Object> value) final {
-    ElementsAccessorSubclass::SetImpl(holder, key, backing_store, value);
+    ElementsAccessorSubclass::SetImpl(backing_store, key, value);
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> backing_store,
+  static void SetImpl(Handle<FixedArrayBase> backing_store, uint32_t key,
                       Handle<Object> value) {
-    CHECK(key <
-          ElementsAccessorSubclass::GetCapacityImpl(*obj, *backing_store));
-    BackingStore::SetValue(obj, Handle<BackingStore>::cast(backing_store), key,
+    BackingStore::SetValue(Handle<BackingStore>::cast(backing_store), key,
                            value);
   }
 
@@ -1447,8 +1443,8 @@ class DictionaryElementsAccessor
     return isolate->factory()->the_hole_value();
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> store, Handle<Object> value) {
+  static void SetImpl(Handle<FixedArrayBase> store, uint32_t key,
+                      Handle<Object> value) {
     Handle<SeededNumberDictionary> backing_store =
         Handle<SeededNumberDictionary>::cast(store);
     int entry = backing_store->FindEntry(key);
@@ -1544,8 +1540,8 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
     }
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> store, Handle<Object> value) {
+  static void SetImpl(Handle<FixedArrayBase> store, uint32_t key,
+                      Handle<Object> value) {
     Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(store);
     Object* probe = GetParameterMapArg(*parameter_map, key);
     if (!probe->IsTheHole()) {
@@ -1555,7 +1551,7 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
       context->set(context_index, *value);
     } else {
       Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
-      ElementsAccessor::ForArray(arguments)->Set(obj, key, arguments, value);
+      ElementsAccessor::ForArray(arguments)->Set(arguments, key, value);
     }
   }
 

diff --git a/src/elements.h b/src/elements.h
index 3067e56..28bf0a1 100644 (file)
--- a/src/elements.h
+++ b/src/elements.h
@@ -43,10 +43,6 @@ class ElementsAccessor {
     return HasElement(holder, key, handle(holder->elements()));
   }
 
-  inline void Set(Handle<JSObject> holder, uint32_t key, Handle<Object> value) {
-    Set(holder, key, handle(holder->elements()), value);
-  }
-
   // Returns the element with the specified key or undefined if there is no such
   // element. This method doesn't iterate up the prototype chain.  The caller
   // can optionally pass in the backing store to use for the check, which must
@@ -179,8 +175,7 @@ class ElementsAccessor {
                                      uint32_t index) = 0;
   virtual bool HasIndex(FixedArrayBase* backing_store, uint32_t key) = 0;
 
-  virtual void Set(Handle<JSObject> holder, uint32_t key,
-                   Handle<FixedArrayBase> backing_store,
+  virtual void Set(Handle<FixedArrayBase> backing_store, uint32_t key,
                    Handle<Object> value) = 0;
 
  private:

diff --git a/src/lookup.cc b/src/lookup.cc
index 783c3f7..fa1ae02 100644 (file)
--- a/src/lookup.cc
+++ b/src/lookup.cc
@@ -420,7 +420,7 @@ void LookupIterator::WriteDataValue(Handle<Object> value) {
   Handle<JSObject> holder = GetHolder<JSObject>();
   if (IsElement()) {
     ElementsAccessor* accessor = holder->GetElementsAccessor();
-    accessor->Set(holder, index_, value);
+    accessor->Set(handle(holder->elements()), index_, value);
   } else if (holder->IsGlobalObject()) {
     Handle<GlobalDictionary> property_dictionary =
         handle(holder->global_dictionary());

diff --git a/src/objects-inl.h b/src/objects-inl.h
index 7a31d1a..db02e61 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -4002,27 +4002,21 @@ Handle<Object> FixedTypedArray<Traits>::get(
 
 
 template <class Traits>
-void FixedTypedArray<Traits>::SetValue(Handle<JSObject> holder,
-                                       Handle<FixedTypedArray<Traits> > array,
+void FixedTypedArray<Traits>::SetValue(Handle<FixedTypedArray<Traits> > array,
                                        uint32_t index, Handle<Object> value) {
   ElementType cast_value = Traits::defaultValue();
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(array->length())) {
-      if (value->IsSmi()) {
-        int int_value = Handle<Smi>::cast(value)->value();
-        cast_value = from_int(int_value);
-      } else if (value->IsHeapNumber()) {
-        double double_value = Handle<HeapNumber>::cast(value)->value();
-        cast_value = from_double(double_value);
-      } else {
-        // Clamp undefined to the default value. All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      array->set(index, cast_value);
-    }
+  if (value->IsSmi()) {
+    int int_value = Handle<Smi>::cast(value)->value();
+    cast_value = from_int(int_value);
+  } else if (value->IsHeapNumber()) {
+    double double_value = Handle<HeapNumber>::cast(value)->value();
+    cast_value = from_double(double_value);
+  } else {
+    // Clamp undefined to the default value. All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  array->set(index, cast_value);
 }
 
 

diff --git a/src/objects.cc b/src/objects.cc
index ec893c9..d63c9e0 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -14715,188 +14715,148 @@ size_t JSTypedArray::element_size() {
 }
 
 
-void FixedArray::SetValue(Handle<JSObject> holder, Handle<FixedArray> array,
-                          uint32_t index, Handle<Object> value) {
+void FixedArray::SetValue(Handle<FixedArray> array, uint32_t index,
+                          Handle<Object> value) {
   array->set(index, *value);
 }
 
 
-void FixedDoubleArray::SetValue(Handle<JSObject> holder,
-                                Handle<FixedDoubleArray> array, uint32_t index,
+void FixedDoubleArray::SetValue(Handle<FixedDoubleArray> array, uint32_t index,
                                 Handle<Object> value) {
   array->set(index, value->Number());
 }
 
 
 void ExternalUint8ClampedArray::SetValue(
-    Handle<JSObject> holder, Handle<ExternalUint8ClampedArray> array,
-    uint32_t index, Handle<Object> value) {
+    Handle<ExternalUint8ClampedArray> array, uint32_t index,
+    Handle<Object> value) {
   uint8_t clamped_value = 0;
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(array->length())) {
-      if (value->IsSmi()) {
-        int int_value = Handle<Smi>::cast(value)->value();
-        if (int_value < 0) {
-          clamped_value = 0;
-        } else if (int_value > 255) {
-          clamped_value = 255;
-        } else {
-          clamped_value = static_cast<uint8_t>(int_value);
-        }
-      } else if (value->IsHeapNumber()) {
-        double double_value = Handle<HeapNumber>::cast(value)->value();
-        if (!(double_value > 0)) {
-          // NaN and less than zero clamp to zero.
-          clamped_value = 0;
-        } else if (double_value > 255) {
-          // Greater than 255 clamp to 255.
-          clamped_value = 255;
-        } else {
-          // Other doubles are rounded to the nearest integer.
-          clamped_value = static_cast<uint8_t>(lrint(double_value));
-        }
-      } else {
-        // Clamp undefined to zero (default). All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      array->set(index, clamped_value);
+  if (value->IsSmi()) {
+    int int_value = Handle<Smi>::cast(value)->value();
+    if (int_value < 0) {
+      clamped_value = 0;
+    } else if (int_value > 255) {
+      clamped_value = 255;
+    } else {
+      clamped_value = static_cast<uint8_t>(int_value);
+    }
+  } else if (value->IsHeapNumber()) {
+    double double_value = Handle<HeapNumber>::cast(value)->value();
+    if (!(double_value > 0)) {
+      // NaN and less than zero clamp to zero.
+      clamped_value = 0;
+    } else if (double_value > 255) {
+      // Greater than 255 clamp to 255.
+      clamped_value = 255;
+    } else {
+      // Other doubles are rounded to the nearest integer.
+      clamped_value = static_cast<uint8_t>(lrint(double_value));
     }
+  } else {
+    // Clamp undefined to zero (default). All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  array->set(index, clamped_value);
 }
 
 
 template <typename ExternalArrayClass, typename ValueType>
-static void ExternalArrayIntSetter(Isolate* isolate, Handle<JSObject> holder,
-                                   Handle<ExternalArrayClass> receiver,
+static void ExternalArrayIntSetter(Handle<ExternalArrayClass> receiver,
                                    uint32_t index, Handle<Object> value) {
   ValueType cast_value = 0;
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(receiver->length())) {
-      if (value->IsSmi()) {
-        int int_value = Handle<Smi>::cast(value)->value();
-        cast_value = static_cast<ValueType>(int_value);
-      } else if (value->IsHeapNumber()) {
-        double double_value = Handle<HeapNumber>::cast(value)->value();
-        cast_value = static_cast<ValueType>(DoubleToInt32(double_value));
-      } else {
-        // Clamp undefined to zero (default). All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      receiver->set(index, cast_value);
-    }
+  if (value->IsSmi()) {
+    int int_value = Handle<Smi>::cast(value)->value();
+    cast_value = static_cast<ValueType>(int_value);
+  } else if (value->IsHeapNumber()) {
+    double double_value = Handle<HeapNumber>::cast(value)->value();
+    cast_value = static_cast<ValueType>(DoubleToInt32(double_value));
+  } else {
+    // Clamp undefined to zero (default). All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  receiver->set(index, cast_value);
 }
 
 
-void ExternalInt8Array::SetValue(Handle<JSObject> holder,
-                                 Handle<ExternalInt8Array> array,
+void ExternalInt8Array::SetValue(Handle<ExternalInt8Array> array,
                                  uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt8Array, int8_t>(array->GetIsolate(), holder,
-                                                    array, index, value);
+  ExternalArrayIntSetter<ExternalInt8Array, int8_t>(array, index, value);
 }
 
 
-void ExternalUint8Array::SetValue(Handle<JSObject> holder,
-                                  Handle<ExternalUint8Array> array,
+void ExternalUint8Array::SetValue(Handle<ExternalUint8Array> array,
                                   uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(
-      array->GetIsolate(), holder, array, index, value);
+  ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(array, index, value);
 }
 
 
-void ExternalInt16Array::SetValue(Handle<JSObject> holder,
-                                  Handle<ExternalInt16Array> array,
+void ExternalInt16Array::SetValue(Handle<ExternalInt16Array> array,
                                   uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt16Array, int16_t>(
-      array->GetIsolate(), holder, array, index, value);
+  ExternalArrayIntSetter<ExternalInt16Array, int16_t>(array, index, value);
 }
 
 
-void ExternalUint16Array::SetValue(Handle<JSObject> holder,
-                                   Handle<ExternalUint16Array> array,
+void ExternalUint16Array::SetValue(Handle<ExternalUint16Array> array,
                                    uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(
-      array->GetIsolate(), holder, array, index, value);
+  ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(array, index, value);
 }
 
 
-void ExternalInt32Array::SetValue(Handle<JSObject> holder,
-                                  Handle<ExternalInt32Array> array,
+void ExternalInt32Array::SetValue(Handle<ExternalInt32Array> array,
                                   uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt32Array, int32_t>(
-      array->GetIsolate(), holder, array, index, value);
+  ExternalArrayIntSetter<ExternalInt32Array, int32_t>(array, index, value);
 }
 
 
-void ExternalUint32Array::SetValue(Handle<JSObject> holder,
-                                   Handle<ExternalUint32Array> array,
+void ExternalUint32Array::SetValue(Handle<ExternalUint32Array> array,
                                    uint32_t index, Handle<Object> value) {
   uint32_t cast_value = 0;
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(array->length())) {
-      if (value->IsSmi()) {
-        int int_value = Handle<Smi>::cast(value)->value();
-        cast_value = static_cast<uint32_t>(int_value);
-      } else if (value->IsHeapNumber()) {
-        double double_value = Handle<HeapNumber>::cast(value)->value();
-        cast_value = static_cast<uint32_t>(DoubleToUint32(double_value));
-      } else {
-        // Clamp undefined to zero (default). All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      array->set(index, cast_value);
-    }
+  if (value->IsSmi()) {
+    int int_value = Handle<Smi>::cast(value)->value();
+    cast_value = static_cast<uint32_t>(int_value);
+  } else if (value->IsHeapNumber()) {
+    double double_value = Handle<HeapNumber>::cast(value)->value();
+    cast_value = static_cast<uint32_t>(DoubleToUint32(double_value));
+  } else {
+    // Clamp undefined to zero (default). All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  array->set(index, cast_value);
 }
 
 
-void ExternalFloat32Array::SetValue(Handle<JSObject> holder,
-                                    Handle<ExternalFloat32Array> array,
+void ExternalFloat32Array::SetValue(Handle<ExternalFloat32Array> array,
                                     uint32_t index, Handle<Object> value) {
   float cast_value = std::numeric_limits<float>::quiet_NaN();
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(array->length())) {
-      if (value->IsSmi()) {
-        int int_value = Handle<Smi>::cast(value)->value();
-        cast_value = static_cast<float>(int_value);
-      } else if (value->IsHeapNumber()) {
-        double double_value = Handle<HeapNumber>::cast(value)->value();
-        cast_value = static_cast<float>(double_value);
-      } else {
-        // Clamp undefined to NaN (default). All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      array->set(index, cast_value);
-    }
+  if (value->IsSmi()) {
+    int int_value = Handle<Smi>::cast(value)->value();
+    cast_value = static_cast<float>(int_value);
+  } else if (value->IsHeapNumber()) {
+    double double_value = Handle<HeapNumber>::cast(value)->value();
+    cast_value = static_cast<float>(double_value);
+  } else {
+    // Clamp undefined to NaN (default). All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  array->set(index, cast_value);
 }
 
 
-void ExternalFloat64Array::SetValue(Handle<JSObject> holder,
-                                    Handle<ExternalFloat64Array> array,
+void ExternalFloat64Array::SetValue(Handle<ExternalFloat64Array> array,
                                     uint32_t index, Handle<Object> value) {
   double double_value = std::numeric_limits<double>::quiet_NaN();
-  Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
-  if (!view->WasNeutered()) {
-    if (index < static_cast<uint32_t>(array->length())) {
-      if (value->IsNumber()) {
-        double_value = value->Number();
-      } else {
-        // Clamp undefined to NaN (default). All other types have been
-        // converted to a number type further up in the call chain.
-        DCHECK(value->IsUndefined());
-      }
-      array->set(index, double_value);
-    }
+  if (value->IsNumber()) {
+    double_value = value->Number();
+  } else {
+    // Clamp undefined to NaN (default). All other types have been
+    // converted to a number type further up in the call chain.
+    DCHECK(value->IsUndefined());
   }
+  array->set(index, double_value);
 }
 
 

diff --git a/src/objects.h b/src/objects.h
index 9fa0e72..3cba6df 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -2439,8 +2439,8 @@ class FixedArray: public FixedArrayBase {
  public:
   // Setter and getter for elements.
   inline Object* get(int index) const;
-  static void SetValue(Handle<JSObject> holder, Handle<FixedArray> array,
-                       uint32_t index, Handle<Object> value);
+  static void SetValue(Handle<FixedArray> array, uint32_t index,
+                       Handle<Object> value);
   static inline Handle<Object> get(Handle<FixedArray> array, int index);
   // Setter that uses write barrier.
   inline void set(int index, Object* value);
@@ -2563,8 +2563,8 @@ class FixedDoubleArray: public FixedArrayBase {
   inline uint64_t get_representation(int index);
   static inline Handle<Object> get(Handle<FixedDoubleArray> array, int index);
   // This accessor has to get a Number as |value|.
-  static void SetValue(Handle<JSObject> holder, Handle<FixedDoubleArray> array,
-                       uint32_t index, Handle<Object> value);
+  static void SetValue(Handle<FixedDoubleArray> array, uint32_t index,
+                       Handle<Object> value);
   inline void set(int index, double value);
   inline void set_the_hole(int index);
 
@@ -4399,8 +4399,7 @@ class ExternalUint8ClampedArray: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined and clamps the converted value between 0 and 255.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalUint8ClampedArray> array, uint32_t index,
+  static void SetValue(Handle<ExternalUint8ClampedArray> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalUint8ClampedArray)
@@ -4423,8 +4422,8 @@ class ExternalInt8Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder, Handle<ExternalInt8Array> array,
-                       uint32_t index, Handle<Object> value);
+  static void SetValue(Handle<ExternalInt8Array> array, uint32_t index,
+                       Handle<Object> value);
 
   DECLARE_CAST(ExternalInt8Array)
 
@@ -4446,8 +4445,7 @@ class ExternalUint8Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalUint8Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalUint8Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalUint8Array)
@@ -4470,8 +4468,7 @@ class ExternalInt16Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalInt16Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalInt16Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalInt16Array)
@@ -4495,8 +4492,7 @@ class ExternalUint16Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalUint16Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalUint16Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalUint16Array)
@@ -4519,8 +4515,7 @@ class ExternalInt32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalInt32Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalInt32Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalInt32Array)
@@ -4544,8 +4539,7 @@ class ExternalUint32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalUint32Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalUint32Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalUint32Array)
@@ -4569,8 +4563,7 @@ class ExternalFloat32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalFloat32Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalFloat32Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalFloat32Array)
@@ -4594,8 +4587,7 @@ class ExternalFloat64Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<ExternalFloat64Array> array, uint32_t index,
+  static void SetValue(Handle<ExternalFloat64Array> array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_CAST(ExternalFloat64Array)
@@ -4664,8 +4656,7 @@ class FixedTypedArray: public FixedTypedArrayBase {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<JSObject> holder,
-                       Handle<FixedTypedArray<Traits> > array, uint32_t index,
+  static void SetValue(Handle<FixedTypedArray<Traits> > array, uint32_t index,
                        Handle<Object> value);
 
   DECLARE_PRINTER(FixedTypedArray)