[stubs] Port StoreTransitionStub and ElementsTransitionAndStoreStub to TurboFan.

src/interface-descriptors.cc

 // Copyright 2012 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/interface-descriptors.h"
 
 namespace v8 {
 namespace internal {
 
 
@@ skipping 119 matching lines @@
                                       machine_types);
 }
 
 void StoreDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
                           SlotRegister()};
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
+bool StoreTransitionDescriptor::PassVectorAndSlotOnStack() {
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
+  return true;
+#else
+  return false;
+#endif
+}
 
 void StoreTransitionDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
-  Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
-                          MapRegister()};
-
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
-
-void VectorStoreTransitionDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  if (SlotRegister().is(no_reg)) {
-    Register registers[] = {ReceiverRegister(), NameRegister(), ValueRegister(),
-                            MapRegister(), VectorRegister()};
-    data->InitializePlatformSpecific(arraysize(registers), registers);
-  } else {
-    Register registers[] = {ReceiverRegister(), NameRegister(),
-                            ValueRegister(),    MapRegister(),
-                            SlotRegister(),     VectorRegister()};
-    data->InitializePlatformSpecific(arraysize(registers), registers);
+  Register registers[] = {
+      ReceiverRegister(), NameRegister(), MapRegister(),
+      ValueRegister(),    SlotRegister(), VectorRegister(),
+  };
+  int len = arraysize(registers);
+  if (PassVectorAndSlotOnStack()) {
+    // Pass slot and vector on the stack.
+    len -= 2;
   }
+  data->InitializePlatformSpecific(len, registers);
 }
 
 void StoreTransitionDescriptor::InitializePlatformIndependent(
     CallInterfaceDescriptorData* data) {
-  // kReceiver, kName, kValue, kMap
+  // kReceiver, kName, kMap, kValue, kSlot, kVector
   MachineType machine_types[] = {
-      MachineType::AnyTagged(), MachineType::AnyTagged(),
-      MachineType::AnyTagged(), MachineType::AnyTagged()};
+      MachineType::AnyTagged(),    MachineType::AnyTagged(),
+      MachineType::AnyTagged(),    MachineType::AnyTagged(),
+      MachineType::TaggedSigned(), MachineType::AnyTagged()};
   data->InitializePlatformIndependent(arraysize(machine_types), 0,
                                       machine_types);
 }
 
 void StoreGlobalViaContextDescriptor::InitializePlatformIndependent(
     CallInterfaceDescriptorData* data) {
   // kSlot, kValue
   MachineType machine_types[] = {MachineType::Int32(),
                                  MachineType::AnyTagged()};
   data->InitializePlatformIndependent(arraysize(machine_types), 0,
@@ skipping 42 matching lines @@
 }
 
 
 void LoadWithVectorDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {ReceiverRegister(), NameRegister(), SlotRegister(),
                           VectorRegister()};
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void VectorStoreTransitionDescriptor::InitializePlatformIndependent(
-    CallInterfaceDescriptorData* data) {
-  bool has_slot = !VectorStoreTransitionDescriptor::SlotRegister().is(no_reg);
-
-  if (has_slot) {
-    // kReceiver, kName, kValue, kMap, kSlot, kVector
-    MachineType machine_types[] = {
-        MachineType::AnyTagged(),    MachineType::AnyTagged(),
-        MachineType::AnyTagged(),    MachineType::AnyTagged(),
-        MachineType::TaggedSigned(), MachineType::AnyTagged()};
-    data->InitializePlatformIndependent(arraysize(machine_types), 0,
-                                        machine_types);
-  } else {
-    // kReceiver, kName, kValue, kMap, kVector
-    MachineType machine_types[] = {
-        MachineType::AnyTagged(), MachineType::AnyTagged(),
-        MachineType::AnyTagged(), MachineType::AnyTagged(),
-        MachineType::AnyTagged()};
-    data->InitializePlatformIndependent(arraysize(machine_types), 0,
-                                        machine_types);
-  }
-}
-
 void StoreWithVectorDescriptor::InitializePlatformIndependent(
     CallInterfaceDescriptorData* data) {
   // kReceiver, kName, kValue, kSlot, kVector
   MachineType machine_types[] = {
       MachineType::AnyTagged(), MachineType::AnyTagged(),
       MachineType::AnyTagged(), MachineType::TaggedSigned(),
       MachineType::AnyTagged()};
   data->InitializePlatformIndependent(arraysize(machine_types), 0,
                                       machine_types);
 }
@@ skipping 245 matching lines @@
   // kAccumulator, kBytecodeOffset, kBytecodeArray, kDispatchTable
   MachineType machine_types[] = {MachineType::AnyTagged(), MachineType::Int32(),
                                  MachineType::AnyTagged(),
                                  MachineType::AnyTagged()};
   data->InitializePlatformIndependent(arraysize(machine_types), 0,
                                       machine_types);
 }
 
 }  // namespace internal
 }  // namespace v8