Teach TurboFan to call vector-based ICs.

src/compiler/js-operator.h

 // Copyright 2013 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_COMPILER_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/runtime/runtime.h"
 #include "src/unique.h"
 
@@ skipping 78 matching lines @@
 bool operator==(ContextAccess const&, ContextAccess const&);
 bool operator!=(ContextAccess const&, ContextAccess const&);
 
 size_t hash_value(ContextAccess const&);
 
 std::ostream& operator<<(std::ostream&, ContextAccess const&);
 
 ContextAccess const& ContextAccessOf(Operator const*);
 
 
+class VectorSlotPair {
+ public:
+  VectorSlotPair(Handle<TypeFeedbackVector> vector, int slot)
+      : vector_(vector), slot_(slot) {}
+
+  Handle<TypeFeedbackVector> vector() const { return vector_; }
+  int slot() const { return slot_; }
+
+ private:
+  const Handle<TypeFeedbackVector> vector_;
+  const int slot_;
+};
+
+
+bool operator==(VectorSlotPair const& lhs, VectorSlotPair const& rhs);
+
+
 // Defines the property being loaded from an object by a named load. This is
 // used as a parameter by JSLoadNamed operators.
 class LoadNamedParameters FINAL {
  public:
-  LoadNamedParameters(const Unique<Name>& name, ContextualMode contextual_mode)
-      : name_(name), contextual_mode_(contextual_mode) {}
+  LoadNamedParameters(const Unique<Name>& name, const VectorSlotPair& feedback,
+                      ContextualMode contextual_mode)
+      : name_(name), contextual_mode_(contextual_mode), feedback_(feedback) {}
 
   const Unique<Name>& name() const { return name_; }
   ContextualMode contextual_mode() const { return contextual_mode_; }
 
+  const VectorSlotPair& feedback() const { return feedback_; }
+
  private:
   const Unique<Name> name_;
   const ContextualMode contextual_mode_;
+  const VectorSlotPair feedback_;
 };
 
 bool operator==(LoadNamedParameters const&, LoadNamedParameters const&);
 bool operator!=(LoadNamedParameters const&, LoadNamedParameters const&);
 
 size_t hash_value(LoadNamedParameters const&);
 
 std::ostream& operator<<(std::ostream&, LoadNamedParameters const&);
 
 const LoadNamedParameters& LoadNamedParametersOf(const Operator* op);
 
 
+// Defines the property being loaded from an object. This is
+// used as a parameter by JSLoadProperty operators.
+class LoadPropertyParameters FINAL {
+ public:
+  explicit LoadPropertyParameters(const VectorSlotPair& feedback)
+      : feedback_(feedback) {}
+
+  const VectorSlotPair& feedback() const { return feedback_; }
+
+ private:
+  const VectorSlotPair feedback_;
+};
+
+bool operator==(LoadPropertyParameters const&, LoadPropertyParameters const&);
+bool operator!=(LoadPropertyParameters const&, LoadPropertyParameters const&);
+
+size_t hash_value(LoadPropertyParameters const&);
+
+std::ostream& operator<<(std::ostream&, LoadPropertyParameters const&);
+
+const LoadPropertyParameters& LoadPropertyParametersOf(const Operator* op);
+
+
 // Defines the property being stored to an object by a named store. This is
 // used as a parameter by JSStoreNamed operators.
 class StoreNamedParameters FINAL {
  public:
   StoreNamedParameters(StrictMode strict_mode, const Unique<Name>& name)
       : strict_mode_(strict_mode), name_(name) {}
 
   StrictMode strict_mode() const { return strict_mode_; }
   const Unique<Name>& name() const { return name_; }
 
@@ skipping 47 matching lines @@
   const Operator* ToObject();
   const Operator* Yield();
 
   const Operator* Create();
 
   const Operator* CallFunction(size_t arity, CallFunctionFlags flags);
   const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
 
   const Operator* CallConstruct(int arguments);
 
-  const Operator* LoadProperty();
+  const Operator* LoadProperty(const VectorSlotPair& feedback);
   const Operator* LoadNamed(const Unique<Name>& name,
+                            const VectorSlotPair& feedback,
                             ContextualMode contextual_mode = NOT_CONTEXTUAL);
 
   const Operator* StoreProperty(StrictMode strict_mode);
   const Operator* StoreNamed(StrictMode strict_mode, const Unique<Name>& name);
 
   const Operator* DeleteProperty(StrictMode strict_mode);
 
   const Operator* HasProperty();
 
   const Operator* LoadContext(size_t depth, size_t index, bool immutable);
@@ skipping 16 matching lines @@
 
   const JSOperatorBuilderImpl& impl_;
   Zone* const zone_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_