[Interpreter] Adds implementation of bytecode graph builder for LoadICSloppy/Strict

src/compiler/bytecode-graph-builder.h

 // Copyright 2015 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_BYTECODE_GRAPH_BUILDER_H_
 #define V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_
 
 #include "src/compiler.h"
 #include "src/compiler/js-graph.h"
 #include "src/interpreter/bytecode-array-iterator.h"
@@ skipping 10 matching lines @@
   BytecodeGraphBuilder(Zone* local_zone, CompilationInfo* info,
                        JSGraph* jsgraph);
 
   // Creates a graph by visiting bytecodes.
   bool CreateGraph(bool stack_check = true);
 
   Graph* graph() const { return jsgraph_->graph(); }
 
  private:
   class Environment;
+  class FrameStateBeforeAndAfter;
 
   void CreateGraphBody(bool stack_check);
   void VisitBytecodes();
 
   Node* LoadAccumulator(Node* value);
 
+  // Get or create the node that represents the outer function closure.
+  Node* GetFunctionClosure();
+
+  // Get or create the node that represents the outer function context.
   Node* GetFunctionContext();
 
+  // Builders for accessing a (potentially immutable) object field.

[rmcilroy, 2015/11/10 18:00:15]

nit - you only have the immutable version here - update comment (until we add
BuildLoadObjectField())

[mythria, 2015/11/11 13:39:24]

Done.

+  Node* BuildLoadImmutableObjectField(Node* object, int offset);
+
+  // Builder for accessing type feedback vector.
+  Node* BuildLoadFeedbackVector();
+
+  // Helper function for creating a pair containing type feedback vector and
+  // a feedback slot.
+  VectorSlotPair CreateVectorSlotPair(int slot_id);
+
+  // Builds deoptimization for a given node.

[rmcilroy, 2015/11/10 18:00:15]

nit - not sure what you mean by "Builds deoptimization" here?

[mythria, 2015/11/11 13:39:24]

Removed this function as discussed in today's meeting

+  // TODO(mythria): Current implementation introduces empty frames. Replace
+  // them with actual frame states.
+  void PrepareFrameState(Node* node);
+
   void set_environment(Environment* env) { environment_ = env; }
   const Environment* environment() const { return environment_; }
   Environment* environment() { return environment_; }
 
   // 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) {
     Node* buffer[] = {n1};
     return MakeNode(op, arraysize(buffer), buffer, false);
   }
 
   Node* NewNode(const Operator* op, Node* n1, Node* n2) {
     Node* buffer[] = {n1, n2};
     return MakeNode(op, arraysize(buffer), buffer, false);
   }
 
+  Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
+    Node* buffer[] = {n1, n2, n3};
+    return MakeNode(op, arraysize(buffer), buffer, false);
+  }
+
   Node* MakeNode(const Operator* op, int value_input_count, Node** value_inputs,
                  bool incomplete);
 
   Node* MergeControl(Node* control, Node* other);
 
   Node** EnsureInputBufferSize(int size);
 
   void UpdateControlDependencyToLeaveFunction(Node* exit);
 
   void BuildBinaryOp(const Operator* op,
                      const interpreter::BytecodeArrayIterator& iterator);
 
+  void BuildNamedLoad(const interpreter::BytecodeArrayIterator& iterator);
+
   // Growth increment for the temporary buffer used to construct input lists to
   // new nodes.
   static const int kInputBufferSizeIncrement = 64;
 
   // Field accessors
   CommonOperatorBuilder* common() const { return jsgraph_->common(); }
   Zone* graph_zone() const { return graph()->zone(); }
   CompilationInfo* info() const { return info_; }
   JSGraph* jsgraph() const { return jsgraph_; }
   JSOperatorBuilder* javascript() const { return jsgraph_->javascript(); }
   Zone* local_zone() const { return local_zone_; }
   const Handle<BytecodeArray>& bytecode_array() const {
     return bytecode_array_;
   }
 
   LanguageMode language_mode() const {
-    // TODO(oth): need to propagate language mode through
-    return LanguageMode::SLOPPY;
+    // TODO(mythria): Don't rely on parse information to get language mode.
+    return info()->language_mode();
   }
 
 #define DECLARE_VISIT_BYTECODE(name, ...) \
   void Visit##name(const interpreter::BytecodeArrayIterator& iterator);
   BYTECODE_LIST(DECLARE_VISIT_BYTECODE)
 #undef DECLARE_VISIT_BYTECODE
 
   Zone* local_zone_;
   CompilationInfo* info_;
   JSGraph* jsgraph_;
   Handle<BytecodeArray> bytecode_array_;
   Environment* environment_;
 
   // Temporary storage for building node input lists.
   int input_buffer_size_;
   Node** input_buffer_;
 
   // Nodes representing values in the activation record.
   SetOncePointer<Node> function_context_;
+  SetOncePointer<Node> function_closure_;
+
+  // Optimization to cache loaded feedback vector.
+  SetOncePointer<Node> feedback_vector_;
 
   // Control nodes that exit the function body.
   ZoneVector<Node*> exit_controls_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeGraphBuilder);
 };
 
 
 class BytecodeGraphBuilder::Environment : public ZoneObject {
  public:
@@ skipping 48 matching lines @@
   NodeVector values_;
   int register_base_;
 };
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_