Teach TurboFan to call vector-based ICs.

src/compiler/ast-graph-builder.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_COMPILER_AST_GRAPH_BUILDER_H_
 #define V8_COMPILER_AST_GRAPH_BUILDER_H_
 
 #include "src/v8.h"
 
 #include "src/ast.h"
@@ skipping 34 matching lines @@
   }
 
   AstContext* ast_context() const { return ast_context_; }
   BreakableScope* breakable() const { return breakable_; }
   ContextScope* execution_context() const { return execution_context_; }
 
   void set_ast_context(AstContext* ctx) { ast_context_ = ctx; }
   void set_breakable(BreakableScope* brk) { breakable_ = brk; }
   void set_execution_context(ContextScope* ctx) { execution_context_ = ctx; }
 
+  LoadICFeedbackNode LoadNamedFeedback(int slot) const {

[Michael Starzinger, 2014/10/08 15:23:09]

As discussed offline: Haveing to deal with IC-related data structures here is a
smell. Can we instead just define a vecotr-slot-pair in js-operators.h that is a
pure data container without logic?

nit: This needs a comment. Also we should make it private (by placing it further
down).

[mvstanton, 2014/10/10 08:26:16]

Done.

+    return LoadICFeedbackNode(vector_, slot);
+  }
+
+  KeyedLoadICFeedbackNode LoadPropertyFeedback(int slot) const {
+    return KeyedLoadICFeedbackNode(vector_, slot);
+  }
+
   // Support for control flow builders. The concrete type of the environment
   // depends on the graph builder, but environments themselves are not virtual.
   typedef StructuredGraphBuilder::Environment BaseEnvironment;
   virtual BaseEnvironment* CopyEnvironment(BaseEnvironment* env);
 
   // TODO(mstarzinger): The pipeline only needs to be a friend to access the
   // function context. Remove as soon as the context is a parameter.
   friend class Pipeline;
 
   // Getters for values in the activation record.
@@ skipping 10 matching lines @@
   Node* BuildLocalFunctionContext(Node* context, Node* closure);
 
   // Builder to create an arguments object if it is used.
   Node* BuildArgumentsObject(Variable* arguments);
 
   // Builders for variable load and assignment.
   Node* BuildVariableAssignment(Variable* var, Node* value, Token::Value op,
                                 BailoutId bailout_id);
   Node* BuildVariableDelete(Variable* var, BailoutId bailout_id,
                             OutputFrameStateCombine state_combine);
-  Node* BuildVariableLoad(Variable* var, BailoutId bailout_id,
+  Node* BuildVariableLoad(VariableProxy* proxy, BailoutId bailout_id,

[Michael Starzinger, 2014/10/08 15:23:09]

Either all the BuildVariableFoo helpers should work on Variable or on
VariableProxy, this arbitrary dichotomy smells.

As discussed offline: It might be better to instead pass the vector-slot-pair as
an argument.

[mvstanton, 2014/10/10 08:26:16]

Done.

                           ContextualMode mode = CONTEXTUAL);
 
   // Builders for accessing the function context.
   Node* BuildLoadBuiltinsObject();
   Node* BuildLoadGlobalObject();
   Node* BuildLoadClosure();
   Node* BuildLoadObjectField(Node* object, int offset);
 
   // Builders for automatic type conversion.
   Node* BuildToBoolean(Node* value);
@@ skipping 15 matching lines @@
 #define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   // Visiting functions for AST nodes make this an AstVisitor.
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   // Visiting function for declarations list is overridden.
   virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
 
  private:
   CompilationInfo* info_;
+  Handle<TypeFeedbackVector> vector_;

[Michael Starzinger, 2014/10/08 15:23:09]

nit: Let's not start caching handles yet, this seems like premature
optimization.

[mvstanton, 2014/10/10 08:26:16]

Done.

   AstContext* ast_context_;
   JSGraph* jsgraph_;
 
   // List of global declarations for functions and variables.
   ZoneList<Handle<Object> > globals_;
 
   // Stack of breakable statements entered by the visitor.
   BreakableScope* breakable_;
 
   // Stack of context objects pushed onto the chain by the visitor.
@@ skipping 297 matching lines @@
 };
 
 Scope* AstGraphBuilder::current_scope() const {
   return execution_context_->scope();
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_