Vector ICs: Introduce Store and KeyedStore IC code stubs.

src/interface-descriptors.h

 // Copyright 2014 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.
 
 #ifndef V8_CALL_INTERFACE_DESCRIPTOR_H_
 #define V8_CALL_INTERFACE_DESCRIPTOR_H_
 
 #include "src/assembler.h"
 #include "src/macro-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 class PlatformInterfaceDescriptor;
 
 #define INTERFACE_DESCRIPTOR_LIST(V)          \
   V(Load)                                     \
   V(Store)                                    \
   V(StoreTransition)                          \
   V(ElementTransitionAndStore)                \
+  V(VectorStoreICTrampoline)                  \
+  V(VectorStoreIC)                            \
   V(Instanceof)                               \
   V(LoadWithVector)                           \
   V(FastNewClosure)                           \
   V(FastNewContext)                           \
   V(ToNumber)                                 \
   V(NumberToString)                           \
   V(Typeof)                                   \
   V(FastCloneShallowArray)                    \
   V(FastCloneShallowObject)                   \
   V(CreateAllocationSite)                     \
@@ skipping 218 matching lines @@
 class InstanceofDescriptor : public CallInterfaceDescriptor {
  public:
   DECLARE_DESCRIPTOR(InstanceofDescriptor, CallInterfaceDescriptor)
 
   enum ParameterIndices { kLeftIndex, kRightIndex, kParameterCount };
   static const Register left();
   static const Register right();
 };
 
 
+class VectorStoreICTrampolineDescriptor : public StoreDescriptor {
+ public:
+  DECLARE_DESCRIPTOR(VectorStoreICTrampolineDescriptor, StoreDescriptor)
+
+  enum ParameterIndices { kReceiverIndex, kNameIndex, kValueIndex, kSlotIndex };
+
+  static const Register SlotRegister();
+};
+
+
+class VectorStoreICDescriptor : public VectorStoreICTrampolineDescriptor {
+ public:
+  DECLARE_DESCRIPTOR(VectorStoreICDescriptor, VectorStoreICTrampolineDescriptor)
+
+  enum ParameterIndices {
+    kReceiverIndex,
+    kNameIndex,
+    kValueIndex,
+    kSlotIndex,
+    kVectorIndex
+  };
+
+  static const Register VectorRegister();
+};
+
+
 class LoadWithVectorDescriptor : public LoadDescriptor {

[Jakob Kummerow, 2015/05/22 11:38:17]

Drive-by: maybe put a TODO here to unify these two, now that loads always use
the vector?

[mvstanton, 2015/05/22 12:06:16]

Ah, okay. No, this is appropriate and maybe it's a naming issue.
Now...LoadDescriptor is a thing that, being inherently vectorized has a
SlotRegister(). And LoadWithVectorDescriptor is for the version of the IC called
by optimized code where the vector is explicitly passed, rather than retrieved
from the frame.

So, "Vector" here, now, means actually pass the vector. The absence of the word
means, please get it from the frame.

The new StoreICs will go through a similar naming convolution, first using the
word Vector to indicate a type of thing...a "vectorized ic", and later using it
to mean something more humdrum. :p

  public:
   DECLARE_DESCRIPTOR(LoadWithVectorDescriptor, LoadDescriptor)
 
   enum ParameterIndices {
     kReceiverIndex,
     kNameIndex,
     kSlotIndex,
     kVectorIndex
   };
 
@@ skipping 283 matching lines @@
 }  // namespace v8::internal
 
 
 #if V8_TARGET_ARCH_ARM64
 #include "src/arm64/interface-descriptors-arm64.h"
 #elif V8_TARGET_ARCH_ARM
 #include "src/arm/interface-descriptors-arm.h"
 #endif
 
 #endif  // V8_CALL_INTERFACE_DESCRIPTOR_H_