Remove handles from ElementsAccessor::Set and friends

BUG=v8:4137
LOG=n

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

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

diff --git a/src/elements.cc b/src/elements.cc
index 20d4264deff660e667670759ccc64a1879476918..53bacf1e50428433270f622682d67a6c7c51f9ad 100644 (file)
--- a/src/elements.cc
+++ b/src/elements.cc
@@ -613,15 +613,14 @@ class ElementsAccessorBase : public ElementsAccessor {
     }
   }
 
-  virtual void Set(Handle<FixedArrayBase> backing_store, uint32_t key,
-                   Handle<Object> value) final {
+  virtual void Set(FixedArrayBase* backing_store, uint32_t key,
+                   Object* value) final {
     ElementsAccessorSubclass::SetImpl(backing_store, key, value);
   }
 
-  static void SetImpl(Handle<FixedArrayBase> backing_store, uint32_t key,
-                      Handle<Object> value) {
-    BackingStore::SetValue(Handle<BackingStore>::cast(backing_store), key,
-                           value);
+  static void SetImpl(FixedArrayBase* backing_store, uint32_t key,
+                      Object* value) {
+    BackingStore::cast(backing_store)->SetValue(key, value);
   }
 
   virtual MaybeHandle<AccessorPair> GetAccessorPair(
@@ -1443,13 +1442,11 @@ class DictionaryElementsAccessor
     return isolate->factory()->the_hole_value();
   }
 
-  static void SetImpl(Handle<FixedArrayBase> store, uint32_t key,
-                      Handle<Object> value) {
-    Handle<SeededNumberDictionary> backing_store =
-        Handle<SeededNumberDictionary>::cast(store);
+  static void SetImpl(FixedArrayBase* store, uint32_t key, Object* value) {
+    SeededNumberDictionary* backing_store = SeededNumberDictionary::cast(store);
     int entry = backing_store->FindEntry(key);
     DCHECK_NE(SeededNumberDictionary::kNotFound, entry);
-    backing_store->ValueAtPut(entry, *value);
+    backing_store->ValueAtPut(entry, value);
   }
 
   static MaybeHandle<AccessorPair> GetAccessorPairImpl(
@@ -1540,17 +1537,16 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
     }
   }
 
-  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);
+  static void SetImpl(FixedArrayBase* store, uint32_t key, Object* value) {
+    FixedArray* parameter_map = FixedArray::cast(store);
+    Object* probe = GetParameterMapArg(parameter_map, key);
     if (!probe->IsTheHole()) {
       Context* context = Context::cast(parameter_map->get(0));
       int context_index = Smi::cast(probe)->value();
       DCHECK(!context->get(context_index)->IsTheHole());
-      context->set(context_index, *value);
+      context->set(context_index, value);
     } else {
-      Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
+      FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
       ElementsAccessor::ForArray(arguments)->Set(arguments, key, value);
     }
   }

diff --git a/src/elements.h b/src/elements.h
index 28bf0a199451a7fb2e014ff158a3ec3b3e4e0f9c..66a96e8f3ddd35c2b5a222cc05545b738057bd16 100644 (file)
--- a/src/elements.h
+++ b/src/elements.h
@@ -175,8 +175,8 @@ class ElementsAccessor {
                                      uint32_t index) = 0;
   virtual bool HasIndex(FixedArrayBase* backing_store, uint32_t key) = 0;
 
-  virtual void Set(Handle<FixedArrayBase> backing_store, uint32_t key,
-                   Handle<Object> value) = 0;
+  virtual void Set(FixedArrayBase* backing_store, uint32_t key,
+                   Object* value) = 0;
 
  private:
   static ElementsAccessor** elements_accessors_;

diff --git a/src/lookup.cc b/src/lookup.cc
index fa1ae0259ad15a914afa4707bfa9aa423199ee4d..834870a454eabd85669d2e607210f3aa18ce9861 100644 (file)
--- a/src/lookup.cc
+++ b/src/lookup.cc
@@ -420,15 +420,14 @@ void LookupIterator::WriteDataValue(Handle<Object> value) {
   Handle<JSObject> holder = GetHolder<JSObject>();
   if (IsElement()) {
     ElementsAccessor* accessor = holder->GetElementsAccessor();
-    accessor->Set(handle(holder->elements()), index_, value);
+    accessor->Set(holder->elements(), index_, *value);
   } else if (holder->IsGlobalObject()) {
     Handle<GlobalDictionary> property_dictionary =
         handle(holder->global_dictionary());
     PropertyCell::UpdateCell(property_dictionary, dictionary_entry(), value,
                              property_details_);
   } else if (holder_map_->is_dictionary_map()) {
-    Handle<NameDictionary> property_dictionary =
-        handle(holder->property_dictionary());
+    NameDictionary* property_dictionary = holder->property_dictionary();
     property_dictionary->ValueAtPut(dictionary_entry(), *value);
   } else if (property_details_.type() == v8::internal::DATA) {
     holder->WriteToField(descriptor_number(), *value);

diff --git a/src/objects-inl.h b/src/objects-inl.h
index db02e615662333147a3b6ac21c461253586ba42d..203f152d9bc2e882e31cd515341e1419c47fe030 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -4002,21 +4002,20 @@ Handle<Object> FixedTypedArray<Traits>::get(
 
 
 template <class Traits>
-void FixedTypedArray<Traits>::SetValue(Handle<FixedTypedArray<Traits> > array,
-                                       uint32_t index, Handle<Object> value) {
+void FixedTypedArray<Traits>::SetValue(uint32_t index, Object* value) {
   ElementType cast_value = Traits::defaultValue();
   if (value->IsSmi()) {
-    int int_value = Handle<Smi>::cast(value)->value();
+    int int_value = Smi::cast(value)->value();
     cast_value = from_int(int_value);
   } else if (value->IsHeapNumber()) {
-    double double_value = Handle<HeapNumber>::cast(value)->value();
+    double double_value = 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);
+  set(index, cast_value);
 }
 
 

diff --git a/src/objects.cc b/src/objects.cc
index d63c9e08882ecda10952962aa53881db676f472f..cff5872550bff550fbdcc6f2e9bd1e1b2e8059a2 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -14715,24 +14715,18 @@ size_t JSTypedArray::element_size() {
 }
 
 
-void FixedArray::SetValue(Handle<FixedArray> array, uint32_t index,
-                          Handle<Object> value) {
-  array->set(index, *value);
-}
+void FixedArray::SetValue(uint32_t index, Object* value) { set(index, value); }
 
 
-void FixedDoubleArray::SetValue(Handle<FixedDoubleArray> array, uint32_t index,
-                                Handle<Object> value) {
-  array->set(index, value->Number());
+void FixedDoubleArray::SetValue(uint32_t index, Object* value) {
+  set(index, value->Number());
 }
 
 
-void ExternalUint8ClampedArray::SetValue(
-    Handle<ExternalUint8ClampedArray> array, uint32_t index,
-    Handle<Object> value) {
+void ExternalUint8ClampedArray::SetValue(uint32_t index, Object* value) {
   uint8_t clamped_value = 0;
   if (value->IsSmi()) {
-    int int_value = Handle<Smi>::cast(value)->value();
+    int int_value = Smi::cast(value)->value();
     if (int_value < 0) {
       clamped_value = 0;
     } else if (int_value > 255) {
@@ -14741,7 +14735,7 @@ void ExternalUint8ClampedArray::SetValue(
       clamped_value = static_cast<uint8_t>(int_value);
     }
   } else if (value->IsHeapNumber()) {
-    double double_value = Handle<HeapNumber>::cast(value)->value();
+    double double_value = HeapNumber::cast(value)->value();
     if (!(double_value > 0)) {
       // NaN and less than zero clamp to zero.
       clamped_value = 0;
@@ -14757,19 +14751,19 @@ void ExternalUint8ClampedArray::SetValue(
     // converted to a number type further up in the call chain.
     DCHECK(value->IsUndefined());
   }
-  array->set(index, clamped_value);
+  set(index, clamped_value);
 }
 
 
 template <typename ExternalArrayClass, typename ValueType>
-static void ExternalArrayIntSetter(Handle<ExternalArrayClass> receiver,
-                                   uint32_t index, Handle<Object> value) {
+static void ExternalArrayIntSetter(ExternalArrayClass* receiver, uint32_t index,
+                                   Object* value) {
   ValueType cast_value = 0;
   if (value->IsSmi()) {
-    int int_value = Handle<Smi>::cast(value)->value();
+    int int_value = Smi::cast(value)->value();
     cast_value = static_cast<ValueType>(int_value);
   } else if (value->IsHeapNumber()) {
-    double double_value = Handle<HeapNumber>::cast(value)->value();
+    double double_value = HeapNumber::cast(value)->value();
     cast_value = static_cast<ValueType>(DoubleToInt32(double_value));
   } else {
     // Clamp undefined to zero (default). All other types have been
@@ -14780,74 +14774,66 @@ static void ExternalArrayIntSetter(Handle<ExternalArrayClass> receiver,
 }
 
 
-void ExternalInt8Array::SetValue(Handle<ExternalInt8Array> array,
-                                 uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt8Array, int8_t>(array, index, value);
+void ExternalInt8Array::SetValue(uint32_t index, Object* value) {
+  ExternalArrayIntSetter<ExternalInt8Array, int8_t>(this, index, value);
 }
 
 
-void ExternalUint8Array::SetValue(Handle<ExternalUint8Array> array,
-                                  uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(array, index, value);
+void ExternalUint8Array::SetValue(uint32_t index, Object* value) {
+  ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(this, index, value);
 }
 
 
-void ExternalInt16Array::SetValue(Handle<ExternalInt16Array> array,
-                                  uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt16Array, int16_t>(array, index, value);
+void ExternalInt16Array::SetValue(uint32_t index, Object* value) {
+  ExternalArrayIntSetter<ExternalInt16Array, int16_t>(this, index, value);
 }
 
 
-void ExternalUint16Array::SetValue(Handle<ExternalUint16Array> array,
-                                   uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(array, index, value);
+void ExternalUint16Array::SetValue(uint32_t index, Object* value) {
+  ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(this, index, value);
 }
 
 
-void ExternalInt32Array::SetValue(Handle<ExternalInt32Array> array,
-                                  uint32_t index, Handle<Object> value) {
-  ExternalArrayIntSetter<ExternalInt32Array, int32_t>(array, index, value);
+void ExternalInt32Array::SetValue(uint32_t index, Object* value) {
+  ExternalArrayIntSetter<ExternalInt32Array, int32_t>(this, index, value);
 }
 
 
-void ExternalUint32Array::SetValue(Handle<ExternalUint32Array> array,
-                                   uint32_t index, Handle<Object> value) {
+void ExternalUint32Array::SetValue(uint32_t index, Object* value) {
   uint32_t cast_value = 0;
   if (value->IsSmi()) {
-    int int_value = Handle<Smi>::cast(value)->value();
+    int int_value = Smi::cast(value)->value();
     cast_value = static_cast<uint32_t>(int_value);
   } else if (value->IsHeapNumber()) {
-    double double_value = Handle<HeapNumber>::cast(value)->value();
+    double double_value = 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);
+  set(index, cast_value);
 }
 
 
-void ExternalFloat32Array::SetValue(Handle<ExternalFloat32Array> array,
-                                    uint32_t index, Handle<Object> value) {
+void ExternalFloat32Array::SetValue(uint32_t index, Object* value) {
   float cast_value = std::numeric_limits<float>::quiet_NaN();
   if (value->IsSmi()) {
-    int int_value = Handle<Smi>::cast(value)->value();
+    int int_value = Smi::cast(value)->value();
     cast_value = static_cast<float>(int_value);
   } else if (value->IsHeapNumber()) {
-    double double_value = Handle<HeapNumber>::cast(value)->value();
+    double double_value = 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);
+  set(index, cast_value);
 }
 
 
-void ExternalFloat64Array::SetValue(Handle<ExternalFloat64Array> array,
-                                    uint32_t index, Handle<Object> value) {
+void ExternalFloat64Array::SetValue(uint32_t index, Object* value) {
   double double_value = std::numeric_limits<double>::quiet_NaN();
   if (value->IsNumber()) {
     double_value = value->Number();
@@ -14856,7 +14842,7 @@ void ExternalFloat64Array::SetValue(Handle<ExternalFloat64Array> array,
     // converted to a number type further up in the call chain.
     DCHECK(value->IsUndefined());
   }
-  array->set(index, double_value);
+  set(index, double_value);
 }
 
 

diff --git a/src/objects.h b/src/objects.h
index 3cba6df84d7d70ff37d8e1f1885e4f403a9af749..4f73eb42e7a057a77db18a8af84dd7a98773b508 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -2439,8 +2439,7 @@ class FixedArray: public FixedArrayBase {
  public:
   // Setter and getter for elements.
   inline Object* get(int index) const;
-  static void SetValue(Handle<FixedArray> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, 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 +2562,7 @@ 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<FixedDoubleArray> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
   inline void set(int index, double value);
   inline void set_the_hole(int index);
 
@@ -4399,8 +4397,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<ExternalUint8ClampedArray> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalUint8ClampedArray)
 
@@ -4422,8 +4419,7 @@ class ExternalInt8Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalInt8Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalInt8Array)
 
@@ -4445,8 +4441,7 @@ class ExternalUint8Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalUint8Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalUint8Array)
 
@@ -4468,8 +4463,7 @@ class ExternalInt16Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalInt16Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalInt16Array)
 
@@ -4492,8 +4486,7 @@ class ExternalUint16Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalUint16Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalUint16Array)
 
@@ -4515,8 +4508,7 @@ class ExternalInt32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalInt32Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalInt32Array)
 
@@ -4539,8 +4531,7 @@ class ExternalUint32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalUint32Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalUint32Array)
 
@@ -4563,8 +4554,7 @@ class ExternalFloat32Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalFloat32Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalFloat32Array)
 
@@ -4587,8 +4577,7 @@ class ExternalFloat64Array: public ExternalArray {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<ExternalFloat64Array> array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_CAST(ExternalFloat64Array)
 
@@ -4656,8 +4645,7 @@ class FixedTypedArray: public FixedTypedArrayBase {
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
-  static void SetValue(Handle<FixedTypedArray<Traits> > array, uint32_t index,
-                       Handle<Object> value);
+  void SetValue(uint32_t index, Object* value);
 
   DECLARE_PRINTER(FixedTypedArray)
   DECLARE_VERIFIER(FixedTypedArray)