[interpreter] Translate exception handlers into graph.

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/bytecode-branch-analysis.h"
 #include "src/compiler/js-graph.h"
@@ skipping 157 matching lines @@
   void BuildConditionalJump(Node* condition);
   void BuildJumpIfEqual(Node* comperand);
   void BuildJumpIfToBooleanEqual(Node* boolean_comperand);
 
   // Constructing merge and loop headers.
   void MergeEnvironmentsOfBackwardBranches(int source_offset,
                                            int target_offset);
   void MergeEnvironmentsOfForwardBranches(int source_offset);
   void BuildLoopHeaderForBackwardBranches(int source_offset);
 
+  // Simulates entry and exit of exception handlers.
+  void EnterAndExitExceptionHandlers(int current_offset);
+
   // Attaches a frame state to |node| for the entry to the function.
   void PrepareEntryFrameState(Node* node);
 
   // Growth increment for the temporary buffer used to construct input lists to
   // new nodes.
   static const int kInputBufferSizeIncrement = 64;
 
+  // An abstract representation for an exception handler that is being
+  // entered and exited while the graph builder is iterating over the
+  // underlying bytecode. The exception handlers within the bytecode are
+  // well scoped, hence will form a stack during iteration.
+  struct ExceptionHandler {
+    int start_offset_;    // Start offset of the handled area in the bytecode.
+    int end_offset_;      // End offset of the handled area in the bytecode.
+    int handler_offset_;  // Handler entry offset within the bytecode.
+  };
+
   // 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_;
   }
+  const Handle<HandlerTable>& exception_handler_table() const {
+    return exception_handler_table_;
+  }
   const FrameStateFunctionInfo* frame_state_function_info() const {
     return frame_state_function_info_;
   }
 
   LanguageMode language_mode() const {
     // TODO(mythria): Don't rely on parse information to get language mode.
     return info()->language_mode();
   }
 
   const interpreter::BytecodeArrayIterator* bytecode_iterator() const {
     return bytecode_iterator_;
   }
 
   void set_bytecode_iterator(
       const interpreter::BytecodeArrayIterator* bytecode_iterator) {
     bytecode_iterator_ = bytecode_iterator;
   }
 
   const BytecodeBranchAnalysis* branch_analysis() const {
     return branch_analysis_;
   }
 
-  void set_branch_analysis(const BytecodeBranchAnalysis* branch_analysis) {
+  void set_branch_analysis(BytecodeBranchAnalysis* branch_analysis) {
     branch_analysis_ = branch_analysis;
   }
 
 #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_;
+  Handle<HandlerTable> exception_handler_table_;
   const FrameStateFunctionInfo* frame_state_function_info_;
   const interpreter::BytecodeArrayIterator* bytecode_iterator_;
-  const BytecodeBranchAnalysis* branch_analysis_;
+  BytecodeBranchAnalysis* branch_analysis_;  // TODO(mstarzinger): Make const.
   Environment* environment_;
 
-
   // Merge environments are snapshots of the environment at a particular
   // bytecode offset to be merged into a later environment.
   ZoneMap<int, Environment*> merge_environments_;
 
   // Loop header environments are environments created for bytecodes
   // where it is known there are back branches, ie a loop header.
   ZoneMap<int, Environment*> loop_header_environments_;
 
+  // Exception handlers currently entered by the iteration.
+  ZoneStack<ExceptionHandler> exception_handlers_;
+  int current_exception_handler_;
+
   // 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_;
   SetOncePointer<Node> new_target_;
 
   // Optimization to cache loaded feedback vector.
@@ skipping 88 matching lines @@
   Node* accumulator_state_values_;
   int register_base_;
   int accumulator_base_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_GRAPH_BUILDER_H_