Reland of [refactoring] Split CodeAssemblerState out of CodeAssembler

src/ic/keyed-store-generic.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/keyed-store-generic.h"
 
-#include "src/compiler/code-assembler.h"
+#include "src/code-stub-assembler.h"
 #include "src/contexts.h"
+#include "src/interface-descriptors.h"
 #include "src/isolate.h"
 
 namespace v8 {
 namespace internal {
 
 using compiler::Node;
 
 class KeyedStoreGenericAssembler : public CodeStubAssembler {
  public:
+  explicit KeyedStoreGenericAssembler(compiler::CodeAssemblerState* state)
+      : CodeStubAssembler(state) {}
+
   void KeyedStoreGeneric(const StoreICParameters* p,
                          LanguageMode language_mode);
 
  private:
   enum UpdateLength {
     kDontChangeLength,
     kIncrementLengthByOne,
     kBumpLengthWithGap
   };
 
@@ skipping 24 matching lines @@
                                  Node* native_context, ElementsKind packed_kind,
                                  ElementsKind holey_kind, Label* done,
                                  Label* map_mismatch, Label* bailout);
   void TryChangeToHoleyMap(Node* receiver, Node* receiver_map,
                            Node* current_elements_kind, Node* context,
                            ElementsKind packed_kind, Label* bailout);
   void TryChangeToHoleyMapMulti(Node* receiver, Node* receiver_map,
                                 Node* current_elements_kind, Node* context,
                                 ElementsKind packed_kind,
                                 ElementsKind packed_kind_2, Label* bailout);
-
-  // Do not add fields, so that this is safe to reinterpret_cast to CSA.
 };
 
-void KeyedStoreGenericGenerator::Generate(
-    CodeStubAssembler* assembler, const CodeStubAssembler::StoreICParameters* p,
-    LanguageMode language_mode) {
-  STATIC_ASSERT(sizeof(CodeStubAssembler) ==
-                sizeof(KeyedStoreGenericAssembler));
-  auto assm = reinterpret_cast<KeyedStoreGenericAssembler*>(assembler);
-  assm->KeyedStoreGeneric(p, language_mode);
+void KeyedStoreGenericGenerator::Generate(compiler::CodeAssemblerState* state,
+                                          LanguageMode language_mode) {
+  typedef StoreWithVectorDescriptor Descriptor;
+  KeyedStoreGenericAssembler assembler(state);
+
+  Node* receiver = assembler.Parameter(Descriptor::kReceiver);
+  Node* name = assembler.Parameter(Descriptor::kName);
+  Node* value = assembler.Parameter(Descriptor::kValue);
+  Node* slot = assembler.Parameter(Descriptor::kSlot);
+  Node* vector = assembler.Parameter(Descriptor::kVector);
+  Node* context = assembler.Parameter(Descriptor::kContext);
+
+  CodeStubAssembler::StoreICParameters p(context, receiver, name, value, slot,
+                                         vector);
+  assembler.KeyedStoreGeneric(&p, language_mode);
 }
 
 void KeyedStoreGenericAssembler::BranchIfPrototypesHaveNonFastElements(
     Node* receiver_map, Label* non_fast_elements, Label* only_fast_elements) {
   Variable var_map(this, MachineRepresentation::kTagged);
   var_map.Bind(receiver_map);
   Label loop_body(this, &var_map);
   Goto(&loop_body);
 
   Bind(&loop_body);
@@ skipping 457 matching lines @@
   Bind(&slow);
   {
     Comment("KeyedStoreGeneric_slow");
     TailCallRuntime(Runtime::kSetProperty, p->context, p->receiver, p->name,
                     p->value, SmiConstant(language_mode));
   }
 }
 
 }  // namespace internal
 }  // namespace v8