[turbofan] Avoid embedding type feedback vector into code.

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/ast.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/liveness-analyzer.h"
@@ skipping 70 matching lines @@
 
   // Stack of control scopes currently entered by the visitor.
   ControlScope* execution_control_;
 
   // Stack of context objects pushed onto the chain by the visitor.
   ContextScope* execution_context_;
 
   // Nodes representing values in the activation record.
   SetOncePointer<Node> function_closure_;
   SetOncePointer<Node> function_context_;
-  SetOncePointer<Node> feedback_vector_;
 
   // Tracks how many try-blocks are currently entered.
   int try_catch_nesting_level_;
   int try_nesting_level_;
 
   // Temporary storage for building node input lists.
   int input_buffer_size_;
   Node** input_buffer_;
 
+  // Optimization to cache loaded feedback vector.
+  // TODO(mstarzinger): Can we let GVN take care of that?

[Michael Starzinger, 2015/06/22 14:57:56]

Is there particular reason why machine loads are not marked as kIdempotent?

[Benedikt Meurer, 2015/06/23 04:12:38]

I'm not sure if we can mark Load as idempotent. We could try.
But independent of that, we should still canonicalize the feedback vector in the
AstGraphBuilder; this optimization is cheap and local, and w/o it we'd create
two additional nodes per feedback vector user.

[Michael Starzinger, 2015/06/23 07:59:22]

Acknowledged. Removed the TODO.

+  SetOncePointer<Node> feedback_vector_;
+
   // Control nodes that exit the function body.
   ZoneVector<Node*> exit_controls_;
 
   // Result of loop assignment analysis performed before graph creation.
   LoopAssignmentAnalysis* loop_assignment_analysis_;
 
   // Cache for StateValues nodes for frame states.
   StateValuesCache state_values_cache_;
 
   // Analyzer of local variable liveness.
@@ skipping 31 matching lines @@
   // Create the main graph body by visiting the AST.
   void CreateGraphBody(bool stack_check);
 
   // Create the node that represents the outer context of the function.
   void CreateFunctionContext(bool constant_context);
 
   // Get or create the node that represents the outer function closure.
   Node* GetFunctionClosureForContext();
   Node* GetFunctionClosure();
 
-  // Get or create the node that represents the functions type feedback vector.
-  Node* GetFeedbackVector();
-
   // Node creation helpers.
   Node* NewNode(const Operator* op, bool incomplete = false) {
     return MakeNode(op, 0, static_cast<Node**>(NULL), incomplete);
   }
 
   Node* NewNode(const Operator* op, Node* n1) {
     return MakeNode(op, 1, &n1, false);
   }
 
   Node* NewNode(const Operator* op, Node* n1, Node* n2) {
@@ skipping 134 matching lines @@
                              Handle<Name> name, Node* value, TypeFeedbackId id);
   Node* BuildNamedSuperLoad(Node* receiver, Node* home_object,
                             Handle<Name> name, const VectorSlotPair& feedback);
   Node* BuildKeyedSuperLoad(Node* receiver, Node* home_object, Node* key,
                             const VectorSlotPair& feedback);
 
   // Builders for accessing the function context.
   Node* BuildLoadBuiltinsObject();
   Node* BuildLoadGlobalObject();
   Node* BuildLoadGlobalProxy();
-  Node* BuildLoadClosure();
-  Node* BuildLoadObjectField(Node* object, int offset);
+  Node* BuildLoadFeedbackVector();
+
+  // Builder for accessing a (potentially immutable) object field.
+  Node* BuildLoadObjectField(Node* object, int offset, bool immutable = false);
 
   // Builders for accessing external references.
   Node* BuildLoadExternal(ExternalReference ref, MachineType type);
   Node* BuildStoreExternal(ExternalReference ref, MachineType type, Node* val);
 
   // Builders for automatic type conversion.
   Node* BuildToBoolean(Node* input);
   Node* BuildToName(Node* input, BailoutId bailout_id);
   Node* BuildToObject(Node* input, BailoutId bailout_id);
 
@@ skipping 214 matching lines @@
 
   // Prepare environment to be used as loop header.
   void PrepareForLoop(BitVector* assigned, bool is_osr = false);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_