Added vector-based loadic hydrogen stubs. Not yet callable.

src/code-stubs.h

 // 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.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 58 matching lines @@
   V(ElementsTransitionAndStore)             \
   V(TransitionElementsKind)                 \
   V(StoreArrayLiteralElement)               \
   V(StubFailureTrampoline)                  \
   V(ArrayConstructor)                       \
   V(InternalArrayConstructor)               \
   V(ProfileEntryHook)                       \
   V(StoreGlobal)                            \
   V(CallApiFunction)                        \
   V(CallApiGetter)                          \
+  V(LoadICTrampoline)                       \
+  V(VectorLoad)                             \
+  V(KeyedLoadICTrampoline)                  \
+  V(VectorKeyedLoad)                        \
   /* IC Handler stubs */                    \
   V(LoadField)                              \
   V(StoreField)                             \
   V(LoadConstant)                           \
   V(StringLength)
 
 // List of code stubs only used on ARM 32 bits platforms.
 #if V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V)  \
   V(GetProperty)               \
@@ skipping 1800 matching lines @@
   virtual InlineCacheState GetICState() const { return GENERIC; }
 
  private:
   Major MajorKey() const { return KeyedLoadGeneric; }
   int NotMissMinorKey() const { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadGenericStub);
 };
 
 
+class LoadICTrampolineStub : public PlatformCodeStub {
+ public:
+  LoadICTrampolineStub(Isolate* isolate, const LoadIC::State& state)
+      : PlatformCodeStub(isolate), state_(state) {}
+
+  virtual Code::Kind GetCodeKind() const V8_OVERRIDE { return Code::LOAD_IC; }
+
+  virtual InlineCacheState GetICState() const V8_FINAL V8_OVERRIDE {
+    return GENERIC;
+  }
+
+  virtual ExtraICState GetExtraICState() const V8_FINAL V8_OVERRIDE {
+    return state_.GetExtraICState();
+  }
+
+ private:
+  Major MajorKey() const { return LoadICTrampoline; }
+  uint32_t MinorKey() const { return GetExtraICState(); }
+
+  void Generate(MacroAssembler* masm);
+
+  const LoadIC::State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadICTrampolineStub);
+};
+
+
+class KeyedLoadICTrampolineStub : public LoadICTrampolineStub {
+ public:
+  explicit KeyedLoadICTrampolineStub(Isolate* isolate)
+      : LoadICTrampolineStub(isolate, LoadIC::State(0)) {}
+
+  virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
+    return Code::KEYED_LOAD_IC;
+  }
+
+ private:
+  Major MajorKey() const { return KeyedLoadICTrampoline; }
+
+  DISALLOW_COPY_AND_ASSIGN(KeyedLoadICTrampolineStub);
+};
+
+
+class VectorLoadStub : public HydrogenCodeStub {
+ public:
+  explicit VectorLoadStub(Isolate* isolate, const LoadIC::State& state)
+      : HydrogenCodeStub(isolate), state_(state) {}
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE;
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
+
+  static void InstallDescriptors(Isolate* isolate);
+
+  virtual Code::Kind GetCodeKind() const V8_OVERRIDE { return Code::LOAD_IC; }
+
+  virtual InlineCacheState GetICState() const V8_FINAL V8_OVERRIDE {
+    return GENERIC;
+  }
+
+  virtual ExtraICState GetExtraICState() const V8_FINAL V8_OVERRIDE {
+    return state_.GetExtraICState();
+  }
+
+ private:
+  Major MajorKey() const { return VectorLoad; }
+  int NotMissMinorKey() const { return state_.GetExtraICState(); }
+
+  const LoadIC::State state_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorLoadStub);
+};
+
+
+class VectorKeyedLoadStub : public VectorLoadStub {
+ public:
+  explicit VectorKeyedLoadStub(Isolate* isolate)
+      : VectorLoadStub(isolate, LoadIC::State(0)) {}
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE;
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
+
+  static void InstallDescriptors(Isolate* isolate);
+
+  virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
+    return Code::KEYED_LOAD_IC;
+  }
+
+ private:
+  Major MajorKey() const { return VectorKeyedLoad; }
+
+  DISALLOW_COPY_AND_ASSIGN(VectorKeyedLoadStub);
+};
+
+
 class DoubleToIStub : public PlatformCodeStub {
  public:
   DoubleToIStub(Isolate* isolate,
                 Register source,
                 Register destination,
                 int offset,
                 bool is_truncating,
                 bool skip_fastpath = false)
       : PlatformCodeStub(isolate), bit_field_(0) {
     bit_field_ = SourceRegisterBits::encode(source.code()) |
@@ skipping 631 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_