[interpreter] Reachability is implied by live environment.

src/compiler/bytecode-branch-analysis.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_BRANCH_ANALYSIS_H_
 #define V8_COMPILER_BYTECODE_BRANCH_ANALYSIS_H_
 
 #include "src/bit-vector.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 class BytecodeArray;
 
 namespace compiler {
 
 class BytecodeBranchInfo;
 
 // A class for identifying the branch targets and their branch sites
-// within a bytecode array and also identifying which bytecodes are
-// reachable. This information can be used to construct the local
-// control flow logic for high-level IR graphs built from bytecode.
+// within a bytecode array. This information can be used to construct
+// the local control flow logic for high-level IR graphs built from
+// bytecode.
 //
 // NB This class relies on the only backwards branches in bytecode
 // being jumps back to loop headers.
 class BytecodeBranchAnalysis BASE_EMBEDDED {
  public:
   BytecodeBranchAnalysis(Handle<BytecodeArray> bytecode_array, Zone* zone);
 
   // Analyze the bytecodes to find the branch sites and their
   // targets. No other methods in this class return valid information
   // until this has been called.
   void Analyze();
 
-  // Returns true if the bytecode at |offset| is reachable.
-  bool is_reachable(int offset) const { return reachable_.Contains(offset); }
-
   // Returns true if there are any forward branches to the bytecode at
   // |offset|.
   bool forward_branches_target(int offset) const {
     const ZoneVector<int>* sites = ForwardBranchesTargetting(offset);
     return sites != nullptr && sites->size() > 0;
   }
 
   // Returns true if there are any backward branches to the bytecode
   // at |offset|.
   bool backward_branches_target(int offset) const {
     const ZoneVector<int>* sites = BackwardBranchesTargetting(offset);
     return sites != nullptr && sites->size() > 0;
   }
 
  private:
   void AddBranch(int origin_offset, int target_offset);
-  void AnalyzeExceptionHandlers();
 
   // Offsets of bytecodes having a backward branch to the bytecode at |offset|.
   const ZoneVector<int>* BackwardBranchesTargetting(int offset) const;
 
   // Offsets of bytecodes having a forward branch to the bytecode at |offset|.
   const ZoneVector<int>* ForwardBranchesTargetting(int offset) const;
 
   Zone* zone() const { return zone_; }
   Handle<BytecodeArray> bytecode_array() const { return bytecode_array_; }
 
   ZoneMap<int, BytecodeBranchInfo*> branch_infos_;
   Handle<BytecodeArray> bytecode_array_;
-  BitVector reachable_;
   Zone* zone_;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeBranchAnalysis);
 };
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_BYTECODE_BRANCH_ANALYSIS_H_