base-hls.hpp

Go to the documentation of this file.

/*
 * Copyright 2021 David Metz <david.c.metz@ntnu.no>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_HLS_BACKEND_RHLS2FIRRTL_BASE_HLS_HPP
#define JLM_HLS_BACKEND_RHLS2FIRRTL_BASE_HLS_HPP
 
#include <jlm/hls/ir/hls.hpp>
#include <jlm/llvm/ir/operators/lambda.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/llvm/ir/RvsdgModule.hpp>
 
#include <fstream>
 
namespace jlm::hls
{
 
bool
isForbiddenChar(char c);
 
class BaseHLS
{
public:
  virtual ~BaseHLS();
 
  std::string
  run(llvm::LlvmRvsdgModule & rm)
  {
    JLM_ASSERT(node_map.empty());
    // ensure consistent naming across runs
    create_node_names(get_hls_lambda(rm)->subregion());
    return GetText(rm);
  }
 
  static int
  JlmSize(const jlm::rvsdg::Type * type);
 
private:
  virtual std::string
  extension() = 0;
 
protected:
  std::unordered_map<const rvsdg::Node *, std::string> node_map;
  std::unordered_map<jlm::rvsdg::Output *, std::string> output_map;
 
  std::string
  get_node_name(const rvsdg::Node * node);
 
  static std::string
  get_port_name(jlm::rvsdg::Input * port);
 
  static std::string
  get_port_name(jlm::rvsdg::Output * port);
 
  const rvsdg::LambdaNode *
  get_hls_lambda(llvm::LlvmRvsdgModule & rm);
 
  void
  create_node_names(rvsdg::Region * r);
 
  virtual std::string
  GetText(llvm::LlvmRvsdgModule & rm) = 0;
 
  static std::string
  get_base_file_name(const llvm::LlvmRvsdgModule & rm);
 
  std::vector<rvsdg::RegionArgument *>
  get_mem_resps(const rvsdg::LambdaNode & lambda)
  {
    std::vector<rvsdg::RegionArgument *> mem_resps;
    for (auto arg : lambda.subregion()->Arguments())
    {
      if (rvsdg::is<BundleType>(arg->Type()))
        mem_resps.push_back(arg);
    }
    return mem_resps;
  }
 
  std::vector<rvsdg::RegionResult *>
  get_mem_reqs(const rvsdg::LambdaNode & lambda)
  {
    std::vector<rvsdg::RegionResult *> mem_resps;
    for (auto result : lambda.subregion()->Results())
    {
      if (rvsdg::is<BundleType>(result->Type()))
        mem_resps.push_back(result);
    }
    return mem_resps;
  }
 
  std::vector<rvsdg::RegionArgument *>
  get_reg_args(const rvsdg::LambdaNode & lambda)
  {
    std::vector<rvsdg::RegionArgument *> args;
    for (auto argument : lambda.subregion()->Arguments())
    {
      if (!rvsdg::is<BundleType>(argument->Type()))
        args.push_back(argument);
    }
    return args;
  }
 
  std::vector<rvsdg::RegionResult *>
  get_reg_results(const rvsdg::LambdaNode & lambda)
  {
    std::vector<rvsdg::RegionResult *> results;
    for (auto result : lambda.subregion()->Results())
    {
      if (!rvsdg::is<BundleType>(result->Type()))
        results.push_back(result);
    }
    return results;
  }
};
 
}
 
#endif // JLM_HLS_BACKEND_RHLS2FIRRTL_BASE_HLS_HPP