[ic] Decode offset from the handler word later in store IC dispatcher.

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 672 matching lines @@
   }
 }
 
 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 = PrepareValueForStore(
       handler_word, holder, representation, transition, value, miss);
 
-  Node* offset = DecodeWord<StoreHandler::FieldOffsetBits>(handler_word);
   Label if_inobject(this), if_out_of_object(this);
   Branch(IsSetWord<StoreHandler::IsInobjectBits>(handler_word), &if_inobject,
          &if_out_of_object);
 
   Bind(&if_inobject);
   {
-    StoreNamedField(holder, offset, true, representation, prepared_value,
+    StoreNamedField(handler_word, holder, true, representation, prepared_value,
                     transition_to_field);
     if (transition_to_field) {
       StoreMap(holder, transition);
     }
     Return(value);
   }
 
   Bind(&if_out_of_object);
   {
     if (transition_to_field) {
       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);
     }
 
-    StoreNamedField(holder, offset, false, representation, prepared_value,
+    StoreNamedField(handler_word, holder, false, representation, prepared_value,
                     transition_to_field);
     if (transition_to_field) {
       StoreMap(holder, transition);
     }
     Return(value);
   }
 }
 
 Node* AccessorAssemblerImpl::PrepareValueForStore(Node* handler_word,
                                                   Node* holder,
@@ skipping 59 matching lines @@
                           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,
+void AccessorAssemblerImpl::StoreNamedField(Node* handler_word, Node* object,
                                             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);
   }
 
+  Node* offset = DecodeWord<StoreHandler::FieldOffsetBits>(handler_word);
   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);
@@ skipping 1097 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