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 {
namespace internal {
namespace compiler {

// The class contains all of the sites that contain
// branches to a particular target (bytecode offset).
class BytecodeBranchInfo final : public ZoneObject {
 public:
  explicit BytecodeBranchInfo(Zone* zone)
      : back_edge_offsets_(zone), fore_edge_offsets_(zone) {}

  void AddBranch(int source_offset, int target_offset);

  // The offsets of bytecodes that refer to this bytecode as
  // a back-edge predecessor.
  const ZoneVector<int>* back_edge_offsets() { return &back_edge_offsets_; }

  // The offsets of bytecodes that refer to this bytecode as
  // a forwards-edge predecessor.
  const ZoneVector<int>* fore_edge_offsets() { return &fore_edge_offsets_; }

 private:
  ZoneVector<int> back_edge_offsets_;
  ZoneVector<int> fore_edge_offsets_;

  DISALLOW_COPY_AND_ASSIGN(BytecodeBranchInfo);
};


void BytecodeBranchInfo::AddBranch(int source_offset, int target_offset) {
  if (source_offset < target_offset) {
    fore_edge_offsets_.push_back(source_offset);
  } 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());
  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);
    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;
      }
    }
    iterator.Advance();
  }
}


const ZoneVector<int>* BytecodeBranchAnalysis::BackwardBranchesTargetting(
    int offset) const {
  auto iterator = branch_infos_.find(offset);
  if (branch_infos_.end() != iterator) {
    return iterator->second->back_edge_offsets();
  } else {
    return nullptr;
  }
}


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::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);
}


}  // namespace compiler
}  // namespace internal
}  // namespace v8