ast_helper.h

Go to the documentation of this file.

#ifndef ILANG_MCM_AST_HELPER_H__
#define ILANG_MCM_AST_HELPER_H__

#include <functional>
#include <set>
#include <unordered_map>
#include <utility>

#include "ilang/ila/instr_lvl_abs.h"
#include "ilang/vtarget-out/directive.h"

namespace ilang {

/******************************************************************************/
// Helper Class
/******************************************************************************/

// T can be ExprPtr or std::string

template <class T> class VarUseFinder {
public:
  typedef std::set<T> VarUseList;
  typedef std::function<T(const ExprPtr&)> ProcessFuncType;
  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  VarUseFinder(ProcessFuncType f) : procFunc(f) {}
  ~VarUseFinder() {}

  // ------------------------- METHODS -------------------------------------- //
  void Traverse(const ExprPtr& expr, VarUseList& uses);
  void Traverse(const InstrPtr& i, VarUseList& uses);
  void Traverse(const InstrLvlAbsPtr& i, VarUseList& uses);

private:
  // ------------------------- MEMBERS -------------------------------------- //
  ProcessFuncType procFunc;
}; // class VarUseFinder

class NestedMemAddrDataAvoider {
  typedef std::unordered_map<Expr*, bool>
      HashTable; // here we do use the raw pointer
public:
  // ------------------------- CONSTRUCTOR ---------------------------------- //
  NestedMemAddrDataAvoider() : InAddrOrData(false) {}
  // ------------------------- METHODS -------------------------------------- //
  bool NotNested(const ExprPtr& node);

private:
  // ------------------------- MEMBERS -------------------------------------- //
  HashTable map_;
  bool InAddrOrData;
}; // class NestedMemAddrDataAvoider

bool getIteUnknownCondVal(const ExprPtr& e, ExprPtr& c, ExprPtr& v);

class FunctionApplicationFinder {
protected:
  // ------------------------- MEMBERS -------------------------------------- //
  std::set<std::shared_ptr<Func>> _func_refs;
  std::set<Expr*> visited;
  void hasFuncAppOnNode(const ExprPtr& e);
  void hasFuncApp(const ExprPtr& expr);

public:
  // ------------------------- CONSTRUCTOR ---------------------------------- //
  FunctionApplicationFinder(const ExprPtr& expr);
  // get the set of the pointer of the functions
  const std::set<std::shared_ptr<Func>> GetReferredFunc() const;
}; // class FunctionApplicationFinder

#if 0
class PureNestedStoreDetector {
  typedef std::vector<std::pair<ExprPtr, ExprPtr>>
      AddrDataVec; // (addr,data) list

  typedef std::unordered_map<Expr*, AddrDataVec>
      HashTable; // here we do use the raw pointer public:

  // ------------------------- METHODS -------------------------------------- //
  bool isNestedStore(const ExprPtr&);
  const AddrDataVec& getStoreAddrDataVec(const ExprPtr&);

private:
  // ------------------------- MEMBERS -------------------------------------- //
  // a map
  HashTable map_;
}
#endif

#if 0
struct MRF_HASH_FUNC {
  std::size_t operator()(const std::pair<TraceStep*, Expr*>& p) const {
    return std::hash()(p.first) ^ std::hash()(p.second);
  }
};
#endif

#if 0
part that exists in a trace step ? class MemReadFinder {
public:
  // Type of (addr,data) pair list
  typedef std::vector<std::pair<ExprPtr, ExprPtr>> AddrDataVec;

private:
  typedef Instr*
      MRFHashKey; // typedef std::pair< TraceStep *, Expr * > MRFHashKey;
  typedef std::unordered_map<std::string, AddrDataVec>
      MRFVal; // statename -> (addr,data) list
  typedef std::unordered_map<MRFHashKey, MRFVal> MRFHashTable;

private:
  // ------------------------- MEMBERS -------------------------------------- //
  void FindAddrDataPairVecInExpr(const ExprPtr& node, MRFVal& nad_map_);
  void VisitNode(const ExprPtr& node, MRFVal& nad_map_);

public:
  const AddrDataVec& FindAddrDataPairVecInInst(const InstrPtr& instr,
                                               const std::string& sname);

  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  MemReadFinder(NestedMemAddrDataAvoider& n) : nested_finder_(n) {}

private:
  // ------------------------- MEMBERS -------------------------------------- //
  MRFHashTable map_;
  NestedMemAddrDataAvoider& nested_finder_;

}; // class MemReadFinder
#endif

} // namespace ilang

#endif // ILANG_MCM_AST_HELPER_H__