Teach TurboFan to call vector-based ICs.

src/compiler/js-operator.cc

Index: src/compiler/js-operator.cc
diff --git a/src/compiler/js-operator.cc b/src/compiler/js-operator.cc
index e0ce3de2b3aca08c7076eb852b9e145411d44a4a..8a85f04c2b933a7eef3f038ffc6ac0f234fbdb2f 100644
--- a/src/compiler/js-operator.cc
+++ b/src/compiler/js-operator.cc
@@ -111,7 +111,8 @@ ContextAccess const& ContextAccessOf(Operator const* op) {
 bool operator==(LoadNamedParameters const& lhs,
                 LoadNamedParameters const& rhs) {
   return lhs.name() == rhs.name() &&
-         lhs.contextual_mode() == rhs.contextual_mode();
+         lhs.contextual_mode() == rhs.contextual_mode() &&
+         lhs.feedback() == rhs.feedback();
 }
 
 
@@ -131,6 +132,35 @@ std::ostream& operator<<(std::ostream& os, LoadNamedParameters const& p) {
 }
 
 
+std::ostream& operator<<(std::ostream& os, LoadPropertyParameters const& p) {
+  // Nothing special to print.
+  return os;
+}
+
+
+bool operator==(LoadPropertyParameters const& lhs,
+                LoadPropertyParameters const& rhs) {
+  return lhs.feedback() == rhs.feedback();
+}
+
+
+bool operator!=(LoadPropertyParameters const& lhs,
+                LoadPropertyParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+const LoadPropertyParameters& LoadPropertyParametersOf(const Operator* op) {
+  DCHECK_EQ(IrOpcode::kJSLoadProperty, op->opcode());
+  return OpParameter<LoadPropertyParameters>(op);
+}
+
+
+size_t hash_value(LoadPropertyParameters const& p) {
+  return hash_value(p.feedback());
+}
+
+
 const LoadNamedParameters& LoadNamedParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSLoadNamed, op->opcode());
   return OpParameter<LoadNamedParameters>(op);
@@ -193,7 +223,6 @@ const StoreNamedParameters& StoreNamedParametersOf(const Operator* op) {
   V(ToObject, Operator::kNoProperties, 1, 1)              \
   V(Yield, Operator::kNoProperties, 1, 1)                 \
   V(Create, Operator::kEliminatable, 0, 1)                \
-  V(LoadProperty, Operator::kNoProperties, 2, 1)          \
   V(HasProperty, Operator::kNoProperties, 2, 1)           \
   V(TypeOf, Operator::kPure, 1, 1)                        \
   V(InstanceOf, Operator::kNoProperties, 2, 1)            \
@@ -261,14 +290,24 @@ const Operator* JSOperatorBuilder::CallConstruct(int arguments) {
 
 
 const Operator* JSOperatorBuilder::LoadNamed(const Unique<Name>& name,
+                                             const LoadICFeedbackNode& feedback,
                                              ContextualMode contextual_mode) {
-  LoadNamedParameters parameters(name, contextual_mode);
+  LoadNamedParameters parameters(name, feedback, contextual_mode);
   return new (zone()) Operator1<LoadNamedParameters>(
       IrOpcode::kJSLoadNamed, Operator::kNoProperties, 1, 1, "JSLoadNamed",
       parameters);
 }
 
 
+const Operator* JSOperatorBuilder::LoadProperty(
+    const KeyedLoadICFeedbackNode& feedback) {
+  LoadPropertyParameters parameters(feedback);
+  return new (zone()) Operator1<LoadPropertyParameters>(
+      IrOpcode::kJSLoadProperty, Operator::kNoProperties, 2, 1,
+      "JSLoadProperty", parameters);
+}
+
+
 const Operator* JSOperatorBuilder::StoreProperty(StrictMode strict_mode) {
   return new (zone())
       Operator1<StrictMode>(IrOpcode::kJSStoreProperty, Operator::kNoProperties,