SplitCFG.h

Go to the documentation of this file.

#ifndef _SPLIT_CFG_H_
#define _SPLIT_CFG_H_
 
#include <unordered_map>
 
#include "SplitCFGBlock.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include <set>
namespace systemc_clang {
 
/* \class Additional information for paths traversed in SplitCFG
 */
 
struct SupplementaryInfo {
  SupplementaryInfo(const SplitCFGBlock *block);
 
  SupplementaryInfo(const SupplementaryInfo &from);
 
  SupplementaryInfo &operator=(const SupplementaryInfo &from);
 
  virtual ~SupplementaryInfo();
 
  int getPathId() const;
 
  int getFalseId() const;
 
  const SplitCFGBlock *getSplitCFGBlock() const;
 
  const SplitCFGBlock *split_block_;
  int false_idx_;
  int path_idx_;
};
 
class SplitCFGPathInfo {
 public:
  using SplitCFGBlockPtrVector = llvm::SmallVector<const SplitCFGBlock *>;
  friend class SplitCFG;
 
 public:
  SplitCFGPathInfo(const SplitCFGBlock *block);
 
  SplitCFGPathInfo(const SplitCFGPathInfo &from);
 
  SplitCFGPathInfo &operator=(const SplitCFGPathInfo &from);
 
  virtual ~SplitCFGPathInfo();
 
  bool isTruePathValid() const { return (true_path_.size() > 0); }
 
  bool isFalsePathValid() const { return ((false_path_.size() > 0)); }
 
  const SplitCFGBlockPtrVector &getTruePath() const { return true_path_; }
 
  const SplitCFGBlockPtrVector &getFalsePath() const { return false_path_; }
 
  // int getpathix() { return false_startix; }
 
  std::string toStringFalsePath() const;
 
  std::string toStringTruePath() const;
 
  void dump() const;
 
 private:
  const SplitCFGBlock *split_block_;
  const clang::CFGBlock *cfg_block_;
  int path_idx_;
  SplitCFGBlockPtrVector false_path_;
  SplitCFGBlockPtrVector true_path_;
};
 
class SplitCFG {
 public:
  using SplitCFGPathPair = std::pair<const SplitCFGBlock *, SupplementaryInfo>;
  using SplitCFGPath = llvm::SmallVector<SplitCFGPathPair>;
 
  // TODO: deprecated
  using VectorSplitCFGBlock = llvm::SmallVector<const SplitCFGBlock *>;
  using VectorSplitCFGBlockImpl = llvm::SmallVector<const SplitCFGBlock *>;
  using VectorCFGElementPtrImpl =
      llvm::SmallVectorImpl<const clang::CFGElement *>;
  using VectorCFGElementPtr = llvm::SmallVector<const clang::CFGElement *>;
 
 private:
  clang::ASTContext &context_;
 
  std::unique_ptr<clang::CFG> cfg_;
 
  std::unordered_map<const clang::CFGBlock *, SplitCFGBlock> split_blocks_;
 
  llvm::SmallVector<SplitCFGPath> paths_;
 
  std::unordered_map<unsigned int, SplitCFGBlock *> sccfg_;
 
  llvm::SmallVector<std::pair<VectorCFGElementPtrImpl, bool>> split_elements;
 
  std::unordered_map<const SplitCFGBlock *,
                     std::pair<const SplitCFGBlock *, unsigned int>>
      wait_next_state_;
 
  std::unordered_map<const SplitCFGBlock *, SplitCFGPathInfo> path_info_;
 
  llvm::SmallVector<std::unordered_map<const SplitCFGBlock *, SplitCFGPathInfo>>
      all_path_info_;
 
  SplitCFGPath sub_path_to_special_node_;
 
  unsigned int next_state_count_;
 
  bool has_ternary_op_;
 
  std::map<SplitCFGBlock*,SplitCFGBlock*> cop_;
 
  SplitCFGBlock *outter_top_;
 
 private:
  bool isElementWait(const clang::CFGElement &element) const;
 
  void splitBlock(clang::CFGBlock *block);
 
  void addSuccessors(SplitCFGBlock *to, const clang::CFGBlock *from);
 
  void addPredecessors(SplitCFGBlock *to, const clang::CFGBlock *from);
 
  void addNextStatesToBlocks();
 
  void createUnsplitBlocks();
 
  void createWaitSplitCFGBlocks(
      clang::CFGBlock *block,
      const llvm::SmallVectorImpl<std::pair<VectorCFGElementPtr, bool>>
          &split_elements);
 
  void dumpSplitElements(
      const llvm::SmallVector<std::pair<VectorCFGElementPtr, bool>>
          &split_elements) const;
 
  void dumpSCCFG() const;
 
 public:
  SplitCFG(clang::ASTContext &context);
  SplitCFG(clang::ASTContext &context, const clang::CXXMethodDecl *cxx_decl);
 
  SplitCFG(const SplitCFG &from) = delete;
 
  SplitCFG &operator=(const SplitCFG &) = delete;
 
  virtual ~SplitCFG();
 
  // const llvm::SmallVectorImpl<VectorSplitCFGBlock> &
 
  const llvm::SmallVectorImpl<llvm::SmallVector<SplitCFGPathPair>>
      &getPathsFound();
 
  void construct_sccfg(const clang::CXXMethodDecl *method);
 
  void generate_paths();
 
  const std::unordered_map<const SplitCFGBlock *, SplitCFGPathInfo>
      &getPathInfo() const;
 
  const llvm::SmallVector<std::unordered_map<const SplitCFGBlock *, SplitCFGPathInfo>>
      &getAllPathInfo() const;
 
  void preparePathInfo();
  llvm::APInt getWaitArgument(const clang::CFGElement &element) const;
 
 
  void dump() const;
  void dumpToDot() const;
  void dumpWaitNextStates() const;
  void dumpPaths() const;
  void dumpCurrPath(
      // llvm::SmallVector<std::pair<const SplitCFGBlock *, SplitCFGPathInfo>>
      SplitCFGPath &curr_path) const;
 
  void dumpPathInfo() const;
  void dumpAllPathInfo() const;
 
  //
  //
 
  // Identify confluence blocks.
  //
  std::map<SplitCFGBlock*,SplitCFGBlock*> getConfluenceBlocks() const;
 
  void identifyConfluenceBlocks();
  std::set<SplitCFGBlock*> identifySkipBlocks();
 
 
 public:
 
  template <typename T>
  void dumpSmallVector(llvm::SmallVectorImpl<T> &vlist) {
    for (const auto v : vlist) {
      llvm::dbgs() << v.first->getBlockID() << " ";
    }
  }
 
 
  const SplitCFGPath  // llvm::SmallVector<std::pair<const SplitCFGBlock *,
                      // SplitCFGPathInfo>>
  dfs_visit_wait(const SplitCFGBlock *BB,
                 llvm::SmallPtrSet<const SplitCFGBlock *, 32> &visited_blocks,
                 llvm::SmallVectorImpl<const SplitCFGBlock *> &waits_to_visit,
                 llvm::SmallPtrSetImpl<const SplitCFGBlock *> &visited_waits,
                 llvm::SmallVector<SplitCFGPathPair> &curr_path);
  void dfs_rework();
 
  bool isTernaryOperator(const SplitCFGBlock *block) const;
 
  bool isLoop(const SplitCFGBlock *block) const;
 
  bool isConditional(const SplitCFGBlock *block) const;
 
  bool getUnvisitedSuccessor(
      const SplitCFGBlock *curr_block, SplitCFGBlock::const_succ_iterator &I,
      llvm::SmallPtrSetImpl<const SplitCFGBlock *> &visited,
      const SplitCFGBlock *&block);
 
  bool isLoopWithTwoSuccessors(const SplitCFGBlock *block) const;
  void addSuccessorToVisitOrPop(
      bool parent_has_wait, const SplitCFGBlock *BB,
      llvm::SmallVector<
          std::pair<const SplitCFGBlock *, SplitCFGBlock::const_succ_iterator>,
          8> &to_visit,
      bool found);
 
  bool isTruePath(const SplitCFGBlock *parent_block,
                  const SplitCFGBlock *block) const;
 
  void setDifference(
      const llvm::SmallPtrSetImpl<const SplitCFGBlock *> &larger,
      const llvm::SmallPtrSetImpl<const SplitCFGBlock *> &smaller,
      llvm::SmallPtrSetImpl<const SplitCFGBlock *> &to);
  void setTruePathInfo(const SplitCFGBlock *sblock,
                       // const llvm::SmallVector< std::pair<const SplitCFGBlock
                       // *, SplitCFGPathInfo>> &newly_visited,
                       const SplitCFGPath &newly_visited, int ix = -1);
 
  void setFalsePathInfo(const SplitCFGBlock *sblock,
                        const SplitCFGPath &newly_visited);
  // const llvm::SmallVector<
  // std::pair<const SplitCFGBlock *, SplitCFGPathInfo>> &newly_visited);
 
  void addPathToSpecialNode(const SplitCFGPath &from);
 
  void updateVisitedBlocks(
      llvm::SmallPtrSetImpl<const SplitCFGBlock *> &to,
      const llvm::SmallPtrSetImpl<const SplitCFGBlock *> &from);
  void dumpVisitedBlocks(llvm::SmallPtrSetImpl<const SplitCFGBlock *> &visited);
 
  bool popping_;
 
 public:
  // void make_edge_pairs( const SplitCFGBlock* block );
};
 
};  // namespace systemc_clang
 
#endif /* _SPLIT_CFG_H_ */