[interpreter] Reachability is implied by live environment.

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 31 matching lines @@
   } else {
     back_edge_offsets_.push_back(source_offset);
   }
 }
 
 
 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.
-        AddBranch(current_offset, iterator.GetJumpTargetOffset());
-        reachable = false;
-      } else if (interpreter::Bytecodes::IsJumpOrReturn(bytecode)) {
-        DCHECK_EQ(bytecode, interpreter::Bytecode::kReturn);
-        reachable = false;
-      }
+    if (interpreter::Bytecodes::IsJump(bytecode)) {
+      AddBranch(current_offset, iterator.GetJumpTargetOffset());
     }
     iterator.Advance();
   }
 }
 
 
 const ZoneVector<int>* BytecodeBranchAnalysis::BackwardBranchesTargetting(
     int offset) const {
   auto iterator = branch_infos_.find(offset);
   if (branch_infos_.end() != iterator) {
@@ skipping 19 matching lines @@
   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