SplitCFGBlock.h

Go to the documentation of this file.

//===- SplitCFGBlock.h - Split the CFGBlock separated by waits -*- C++
//-*-=====//
//
// Part of the systemc-clang project.
// See License.rst
//
//===----------------------------------------------------------------------===//
//
//
//===----------------------------------------------------------------------===//
 
#ifndef _SPLIT_CFG_BLOCK_H_
#define _SPLIT_CFG_BLOCK_H_
 
#include "clang/Analysis/CFG.h"
 
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
 
#undef DEBUG_TYPE
#define DEBUG_TYPE "SplitCFGMatcher"
 
using namespace clang::ast_matchers;
 
namespace systemc_clang {
 
class BreakMatcher : public MatchFinder::MatchCallback {
 private:
  bool break_found_;
  bool wait_found_;
 
 public:
  bool hasBreak() const { return break_found_; }
  bool hasWait() const { return wait_found_; }
 
  void registerMatchers(MatchFinder &finder) {
    // clang-format off
    //auto bstmt = stmt(hasDescendant(breakStmt().bind("break_stmt")));
    auto bstmt = findAll(breakStmt().bind("break_stmt"));
    auto wait_stmt = findAll(cxxMemberCallExpr(callee(cxxMethodDecl(hasName("wait")))).bind("wait_stmt"));
    // clang-format on
 
    finder.addMatcher(bstmt, this);
    finder.addMatcher(wait_stmt, this);
  }
 
  virtual void run(const MatchFinder::MatchResult &result) {
    auto bk_stmt = const_cast<clang::Stmt *>(
        result.Nodes.getNodeAs<clang::Stmt>("break_stmt"));
    auto wait_stmt = const_cast<clang::CXXMemberCallExpr *>(
        result.Nodes.getNodeAs<clang::CXXMemberCallExpr>("wait_stmt"));
 
    if (bk_stmt) {
      LLVM_DEBUG(llvm::dbgs() << "## BreakStmt \n");
      break_found_ = true;
    }
    if (wait_stmt) {
      LLVM_DEBUG(llvm::dbgs() << "## Wait\n");
      wait_found_ = true;
    }
  }
 
  void dump() {
    if (break_found_) {
      LLVM_DEBUG(llvm::dbgs() << "## BREAK FOUND\n");
    }
  }
};
 
class SplitCFGBlock {
 public:
  using VectorCFGElementPtr = llvm::SmallVector<const clang::CFGElement *>;
  using VectorCFGElementPtrImpl =
      llvm::SmallVectorImpl<const clang::CFGElement *>;
  using VectorSplitCFGBlockPtr = llvm::SmallVector<const SplitCFGBlock *>;
  using VectorSplitCFGBlockPtrImpl = llvm::SmallVector<const SplitCFGBlock *>;
 
 private:
  friend class SplitCFG;
 
  const clang::CFGBlock *block_;
  bool has_wait_;
 
  bool is_conditional_;
 
  bool is_loop_with_two_succ_;
 
  bool terminator_has_break_;
 
  bool terminator_has_wait_;
 
  unsigned int id_;
  unsigned int next_state_;
  llvm::APInt wait_arg_;
 
 
  llvm::SmallVector<unsigned int> wait_element_ids_;
 
  VectorCFGElementPtr elements_;
  llvm::SmallVector<const SplitCFGBlock *> predecessors_;
  llvm::SmallVector<const SplitCFGBlock *> successors_;
 
 public:
  struct SuccessorIterator {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = SplitCFGBlock;
    using pointer = SplitCFGBlock *;    // or also value_type*
    using reference = SplitCFGBlock &;  // or also value_type&
    using VectorSuccessors = llvm::SmallVector<const SplitCFGBlock *>;
    using const_iterator = VectorSuccessors::const_iterator;
 
   public:
    VectorSuccessors::const_iterator begin() { return succs_.begin(); }
    VectorSuccessors::const_iterator end() { return succs_.end(); }
 
    SuccessorIterator(const llvm::SmallVector<const SplitCFGBlock *> &succ)
        : succs_{succ} {}
 
   private:
    const VectorSuccessors &succs_;
  };
 
 public:
  using succ_iterator = SuccessorIterator;
  using const_succ_iterator = SuccessorIterator::const_iterator;
  using succ_iterator_range = llvm::iterator_range<succ_iterator>;
  using const_succ_iterator_range = llvm::iterator_range<const_succ_iterator>;
 
  bool succ_empty() const { return (successors_.size() == 0); }
  SuccessorIterator::const_iterator succ_begin() const {
    return SuccessorIterator{successors_}.begin();
  }
  SuccessorIterator::const_iterator succ_end() const {
    return SuccessorIterator{successors_}.end();
  }
  // succ_iterator_range succs() { return succ_iterator_range{succ_begin(),
  // succ_end()}; }
  const_succ_iterator_range const_succs() {
    return const_succ_iterator_range{succ_begin(), succ_end()};
  }
 
 private:
  // bool isFunctionCall(const clang::CFGElement &element) const;
  void setNextState(unsigned int state);
 
 public:
  friend class SplitCFG;
  SplitCFGBlock();
 
  SplitCFGBlock(const SplitCFGBlock &from);
 
  const clang::CFGBlock *getCFGBlock() const;
 
  std::size_t getNumOfElements() const;
 
  const VectorCFGElementPtrImpl &getElements() const;
 
  const VectorSplitCFGBlockPtrImpl &getSuccessors() const;
 
  const VectorSplitCFGBlockPtrImpl &getPredecessors() const;
 
  bool hasWait() const;
 
  bool isConditional() const;
 
  bool isLoopWithTwoSuccessors() const;
 
  bool hasTerminatorBreak() const;
 
  bool hasTerminatorWait() const;
 
  unsigned int getBlockID() const;
 
  unsigned int getNextState() const;
 
  llvm::APInt getWaitArg() const;
 
  void insertElements(VectorCFGElementPtr &elements);
 
  void identifyBreaks(clang::ASTContext &context);
 
  void dump() const;
  void dumpColored() const;
};
 
};  // namespace systemc_clang
 
#endif