[ic][stubs] Move more IC-related methods from CSA to AccessorAssembler.

src/ic/accessor-assembler.cc

 // Copyright 2016 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.
 
 #include "src/ic/accessor-assembler.h"
 #include "src/ic/accessor-assembler-impl.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/ic/handler-configuration.h"
@@ skipping 652 matching lines @@
   Bind(&if_double_field);
   {
     Comment("store double field");
     HandleStoreFieldAndReturn(handler_word, holder, Representation::Double(),
                               value, transition, miss);
   }
 
   Bind(&if_heap_object_field);
   {
     Comment("store heap object field");
     // Generate full field type check here and then store value as Tagged.

[Igor Sheludko, 2017/01/10 15:11:13]

Moved this check to PrepareValueForStore().

     Node* prepared_value =
         PrepareValueForWrite(value, Representation::HeapObject(), miss);
     Node* value_index_in_descriptor =
         DecodeWord<StoreHandler::DescriptorValueIndexBits>(handler_word);
     Node* descriptors =
         LoadMapDescriptors(transition ? transition : LoadMap(holder));
     Node* maybe_field_type =
         LoadFixedArrayElement(descriptors, value_index_in_descriptor);
     Label do_store(this);
     GotoIf(TaggedIsSmi(maybe_field_type), &do_store);
@@ skipping 14 matching lines @@
                               value, transition, miss);
   }
 }
 
 void AccessorAssemblerImpl::HandleStoreFieldAndReturn(
     Node* handler_word, Node* holder, Representation representation,
     Node* value, Node* transition, Label* miss) {
   bool transition_to_field = transition != nullptr;
   Node* prepared_value = PrepareValueForWrite(value, representation, miss);
 
   if (transition_to_field) {

[Igor Sheludko, 2017/01/10 15:11:13]

Moved this to if_out_of_object block.

     Label storage_extended(this);
     GotoUnless(IsSetWord<StoreHandler::ExtendStorageBits>(handler_word),
                &storage_extended);
     Comment("[ Extend storage");
     ExtendPropertiesBackingStore(holder);
     Comment("] Extend storage");
     Goto(&storage_extended);
 
     Bind(&storage_extended);
   }
@@ skipping 17 matching lines @@
   {
     StoreNamedField(holder, offset, false, representation, prepared_value,
                     transition_to_field);
     if (transition_to_field) {
       StoreMap(holder, transition);
     }
     Return(value);
   }
 }
 
+Node* AccessorAssemblerImpl::PrepareValueForWrite(Node* value,
+                                                  Representation representation,
+                                                  Label* bailout) {
+  if (representation.IsDouble()) {
+    value = TryTaggedToFloat64(value, bailout);
+  } else if (representation.IsHeapObject()) {
+    // Field type is checked by the handler, here we only check if the value
+    // is a heap object.
+    GotoIf(TaggedIsSmi(value), bailout);
+  } else if (representation.IsSmi()) {
+    GotoUnless(TaggedIsSmi(value), bailout);
+  } else {
+    DCHECK(representation.IsTagged());
+  }
+  return value;
+}
+
+void AccessorAssemblerImpl::ExtendPropertiesBackingStore(Node* object) {
+  Node* properties = LoadProperties(object);
+  Node* length = LoadFixedArrayBaseLength(properties);
+
+  ParameterMode mode = OptimalParameterMode();
+  length = TaggedToParameter(length, mode);
+
+  Node* delta = IntPtrOrSmiConstant(JSObject::kFieldsAdded, mode);
+  Node* new_capacity = IntPtrOrSmiAdd(length, delta, mode);
+
+  // Grow properties array.
+  ElementsKind kind = FAST_ELEMENTS;
+  DCHECK(kMaxNumberOfDescriptors + JSObject::kFieldsAdded <
+         FixedArrayBase::GetMaxLengthForNewSpaceAllocation(kind));
+  // The size of a new properties backing store is guaranteed to be small
+  // enough that the new backing store will be allocated in new space.
+  CSA_ASSERT(this,
+             UintPtrOrSmiLessThan(
+                 new_capacity,
+                 IntPtrOrSmiConstant(
+                     kMaxNumberOfDescriptors + JSObject::kFieldsAdded, mode),
+                 mode));
+
+  Node* new_properties = AllocateFixedArray(kind, new_capacity, mode);
+
+  FillFixedArrayWithValue(kind, new_properties, length, new_capacity,
+                          Heap::kUndefinedValueRootIndex, mode);
+
+  // |new_properties| is guaranteed to be in new space, so we can skip
+  // the write barrier.
+  CopyFixedArrayElements(kind, properties, new_properties, length,
+                         SKIP_WRITE_BARRIER, mode);
+
+  StoreObjectField(object, JSObject::kPropertiesOffset, new_properties);
+}
+
+void AccessorAssemblerImpl::StoreNamedField(Node* object, Node* offset,
+                                            bool is_inobject,
+                                            Representation representation,
+                                            Node* value,
+                                            bool transition_to_field) {
+  bool store_value_as_double = representation.IsDouble();
+  Node* property_storage = object;
+  if (!is_inobject) {
+    property_storage = LoadProperties(object);
+  }
+
+  if (representation.IsDouble()) {
+    if (!FLAG_unbox_double_fields || !is_inobject) {
+      if (transition_to_field) {
+        Node* heap_number = AllocateHeapNumberWithValue(value, MUTABLE);
+        // Store the new mutable heap number into the object.
+        value = heap_number;
+        store_value_as_double = false;
+      } else {
+        // Load the heap number.
+        property_storage = LoadObjectField(property_storage, offset);
+        // Store the double value into it.
+        offset = IntPtrConstant(HeapNumber::kValueOffset);
+      }
+    }
+  }
+
+  if (store_value_as_double) {
+    StoreObjectFieldNoWriteBarrier(property_storage, offset, value,
+                                   MachineRepresentation::kFloat64);
+  } else if (representation.IsSmi()) {
+    StoreObjectFieldNoWriteBarrier(property_storage, offset, value);
+  } else {
+    StoreObjectField(property_storage, offset, value);
+  }
+}
+
 void AccessorAssemblerImpl::EmitFastElementsBoundsCheck(
     Node* object, Node* elements, Node* intptr_index,
     Node* is_jsarray_condition, Label* miss) {
   Variable var_length(this, MachineType::PointerRepresentation());
   Comment("Fast elements bounds check");
   Label if_array(this), length_loaded(this, &var_length);
   GotoIf(is_jsarray_condition, &if_array);
   {
     var_length.Bind(SmiUntag(LoadFixedArrayBaseLength(elements)));
     Goto(&length_loaded);
@@ skipping 1071 matching lines @@
 void AccessorAssembler::GenerateKeyedStoreICTrampolineTF(
     CodeAssemblerState* state, LanguageMode language_mode) {
   AccessorAssemblerImpl assembler(state);
   assembler.GenerateKeyedStoreICTrampolineTF(language_mode);
 }
 
 #undef ACCESSOR_ASSEMBLER_PUBLIC_INTERFACE
 
 }  // namespace internal
 }  // namespace v8