[interpreter] Translate exception handlers into graph.

src/compiler/bytecode-branch-analysis.cc

 // 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.
 
 #include "src/compiler/bytecode-branch-analysis.h"
 
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
@@ skipping 37 matching lines @@
 BytecodeBranchAnalysis::BytecodeBranchAnalysis(
     Handle<BytecodeArray> bytecode_array, Zone* zone)
     : branch_infos_(zone),
       bytecode_array_(bytecode_array),
       reachable_(bytecode_array->length(), zone),
       zone_(zone) {}
 
 
 void BytecodeBranchAnalysis::Analyze() {
   interpreter::BytecodeArrayIterator iterator(bytecode_array());
+  AnalyzeExceptionHandlers();
   bool reachable = true;
   while (!iterator.done()) {
     interpreter::Bytecode bytecode = iterator.current_bytecode();
     int current_offset = iterator.current_offset();
     // All bytecode basic blocks are generated to be forward reachable
     // and may also be backward reachable. Hence if there's a forward
     // branch targetting here the code becomes reachable.
     reachable = reachable || forward_branches_target(current_offset);
+    // Some bytecode basic blocks are reachable through a side-entry
+    // (e.g. exception handler), which has been represented in the
+    // bit-vector by a corresponding pre-pass.
+    reachable = reachable || reachable_.Contains(current_offset);
     if (reachable) {
       reachable_.Add(current_offset);
       if (interpreter::Bytecodes::IsConditionalJump(bytecode)) {
         // Only the branch is recorded, the forward path falls through
         // and is handled as normal bytecode data flow.
         AddBranch(current_offset, iterator.GetJumpTargetOffset());
       } else if (interpreter::Bytecodes::IsJump(bytecode)) {
         // Unless the branch targets the next bytecode it's not
         // reachable. If it targets the next bytecode the check at the
         // start of the loop will set the reachable flag.
@@ skipping 23 matching lines @@
 const ZoneVector<int>* BytecodeBranchAnalysis::ForwardBranchesTargetting(
     int offset) const {
   auto iterator = branch_infos_.find(offset);
   if (branch_infos_.end() != iterator) {
     return iterator->second->fore_edge_offsets();
   } else {
     return nullptr;
   }
 }
 
+void BytecodeBranchAnalysis::AddExceptionalBranch(int throw_offset,
+                                                  int handler_offset) {
+  DCHECK(is_reachable(handler_offset));     // Handler was marked reachable.
+  DCHECK_LT(throw_offset, handler_offset);  // Always a forward branch.
+  AddBranch(throw_offset, handler_offset);
+}
 
 void BytecodeBranchAnalysis::AddBranch(int source_offset, int target_offset) {
   BytecodeBranchInfo* branch_info = nullptr;
   auto iterator = branch_infos_.find(target_offset);
   if (branch_infos_.end() == iterator) {
     branch_info = new (zone()) BytecodeBranchInfo(zone());
     branch_infos_.insert(std::make_pair(target_offset, branch_info));
   } else {
     branch_info = iterator->second;
   }
   branch_info->AddBranch(source_offset, target_offset);
 }
 
+void BytecodeBranchAnalysis::AnalyzeExceptionHandlers() {
+  HandlerTable* table = HandlerTable::cast(bytecode_array()->handler_table());
+  for (int i = 0; i < table->NumberOfRangeEntries(); ++i) {
+    reachable_.Add(table->GetRangeHandler(i));
+  }
+}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8