ilator.h

Go to the documentation of this file.

#ifndef ILANG_TARGET_SC_ILATOR_H__
#define ILANG_TARGET_SC_ILATOR_H__

#include <memory>
#include <string>

#include <fmt/format.h>

#include <ilang/ila/instr_lvl_abs.h>
#include <ilang/util/log.h>

namespace ilang {

#define ILATOR_PRECISE_MEM

class Ilator {
public:
  // ------------------------- CONSTRUCTOR/DESTRUCTOR ----------------------- //
  Ilator(const InstrLvlAbsPtr& m);
  ~Ilator();

  // ------------------------- METHODS -------------------------------------- //
  void Generate(const std::string& dst, bool opt);

private:
  typedef fmt::memory_buffer StrBuff;
  typedef std::unordered_map<ExprPtr, std::string, ExprHash> ExprVarMap;
  class CxxFunc {
  public:
    CxxFunc(const std::string& in_name, const ExprPtr& in_ret,
            const ExprPtr& in_target = nullptr)
        : name(in_name), ret(in_ret), target(in_target) {}
    CxxFunc(const std::string& in_name, const SortPtr& in_ret_type)
        : name(in_name), ret_type(in_ret_type) {}
    const std::string name = "";
    const ExprPtr ret = nullptr;
    const ExprPtr target = nullptr;
    const SortPtr ret_type = nullptr;
    std::vector<SortPtr> args;
  };

  // ------------------------- MEMBERS -------------------------------------- //
  InstrLvlAbsPtr m_;

  std::map<std::string, CxxFunc*> functions_;
  std::map<std::string, CxxFunc*> externs_;
  std::map<std::string, CxxFunc*> memory_updates_;
  std::set<std::string> source_files_;
  std::set<ExprPtr> const_mems_;
  std::set<ExprPtr> global_vars_;

  // ------------------------- HELPERS -------------------------------------- //
  void Reset();
  bool SanityCheck() const;
  bool Bootstrap(const std::string& root, bool opt);

  bool GenerateIlaBasics(const std::string& dir);
  bool GenerateInstrContent(const InstrPtr& instr, const std::string& dir);
  bool GenerateMemoryUpdate(const std::string& dir);
  bool GenerateConstantMemory(const std::string& dir);
  bool GenerateInitialSetup(const std::string& dir);
  bool GenerateExecuteKernel(const std::string& dir);
  bool GenerateGlobalHeader(const std::string& dir);
  bool GenerateBuildSupport(const std::string& dir);

  bool RenderExpr(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsExpr(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsVar(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut) const;
  void DfsConst(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsOp(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsOpMemory(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsOpAppFunc(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsOpSpecial(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut);
  void DfsOpRegular(const ExprPtr& expr, StrBuff& buff, ExprVarMap& lut) const;

  CxxFunc* RegisterFunction(const std::string& func_name,
                            ExprPtr return_expr = nullptr);
  CxxFunc* RegisterExternalFunc(const FuncPtr& func);
  CxxFunc* RegisterMemoryUpdate(const ExprPtr& expr);

  void BeginFuncDef(CxxFunc* func, StrBuff& buff) const;
  void EndFuncDef(CxxFunc* func, StrBuff& buff) const;
  void WriteFuncDecl(CxxFunc* func, StrBuff& buff) const;
  void CommitSource(const std::string& file_name, const std::string& dir,
                    const StrBuff& buff);

  inline std::string GetProjectName() const { return m_->name().str(); }
  static inline std::string GetLocalVar(const ExprVarMap& lut) {
    return fmt::format("local_var_{}", lut.size());
  }
  static inline std::string GetCxxType(const ExprPtr& expr) {
    return GetCxxType(expr->sort());
  }
  static std::string GetCxxType(const SortPtr& sort);
  static std::string GetCxxName(const ExprPtr& expr);
  static std::string GetValidFuncName(const InstrLvlAbsCnstPtr& m);
  static std::string GetDecodeFuncName(const InstrPtr& instr);
  static std::string GetUpdateFuncName(const InstrPtr& instr);
  static std::string GetMemoryFuncName(const ExprPtr& expr);
  inline std::string LookUp(const ExprPtr& e, const ExprVarMap& lut) const {
    auto pos = lut.find(e);
    ILA_ASSERT(pos != lut.end());
    return pos->second;
  }

}; // class Ilator

} // namespace ilang

#endif // ILANG_TARGET_SC_ILATOR_H__