MlirToJlmConverter.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 Magnus Sjalander <work@sjalander.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_MLIR_FRONTEND_MLIRTOJLMCONVERTER_HPP
#define JLM_MLIR_FRONTEND_MLIRTOJLMCONVERTER_HPP
 
#include <jlm/llvm/ir/operators/delta.hpp>
#include <jlm/llvm/ir/operators/lambda.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/llvm/ir/RvsdgModule.hpp>
#include <jlm/rvsdg/bitstring/comparison.hpp>
#include <jlm/rvsdg/bitstring/constant.hpp>
#include <jlm/rvsdg/gamma.hpp>
#include <jlm/rvsdg/theta.hpp>
#include <jlm/util/BijectiveMap.hpp>
 
#include <JLM/JLMDialect.h>
#include <JLM/JLMOps.h>
#include <RVSDG/RVSDGDialect.h>
#include <RVSDG/RVSDGPasses.h>
 
#include <mlir/Dialect/Arith/IR/Arith.h>
#include <mlir/Dialect/LLVMIR/LLVMDialect.h>
 
namespace jlm::mlir
{
 
class MlirToJlmConverter final
{
public:
  MlirToJlmConverter()
      : Context_(std::make_unique<::mlir::MLIRContext>())
  {
    // Load the RVSDG dialect
    Context_->getOrLoadDialect<::mlir::rvsdg::RVSDGDialect>();
    // Load the JLM dialect
    Context_->getOrLoadDialect<::mlir::jlm::JLMDialect>();
    // Load the Arith dialect
    Context_->getOrLoadDialect<::mlir::arith::ArithDialect>();
    // Load the LLVM dialect
    Context_->getOrLoadDialect<::mlir::LLVM::LLVMDialect>();
  }
 
  MlirToJlmConverter(const MlirToJlmConverter &) = delete;
 
  MlirToJlmConverter(MlirToJlmConverter &&) = delete;
 
  MlirToJlmConverter &
  operator=(const MlirToJlmConverter &) = delete;
 
  MlirToJlmConverter &
  operator=(MlirToJlmConverter &&) = delete;
 
  std::unique_ptr<llvm::LlvmRvsdgModule>
  ReadAndConvertMlir(const util::FilePath & filePath);
 
  std::unique_ptr<llvm::LlvmRvsdgModule>
  ConvertMlir(std::unique_ptr<::mlir::Block> & block);
 
  static std::unique_ptr<llvm::LlvmRvsdgModule>
  CreateAndConvert(std::unique_ptr<::mlir::Block> & block)
  {
    jlm::mlir::MlirToJlmConverter converter;
    return converter.ConvertMlir(block);
  }
 
private:
  ::llvm::SmallVector<jlm::rvsdg::Output *>
  ConvertRegion(::mlir::Region & region, rvsdg::Region & rvsdgRegion);
 
  ::llvm::SmallVector<jlm::rvsdg::Output *>
  ConvertBlock(::mlir::Block & block, rvsdg::Region & rvsdgRegion);
 
  static ::llvm::SmallVector<jlm::rvsdg::Output *>
  GetConvertedInputs(
      ::mlir::Operation & mlirOp,
      const std::unordered_map<void *, rvsdg::Output *> & outputMap);
 
  rvsdg::Node *
  ConvertCmpIOp(
      ::mlir::arith::CmpIOp & CompOp,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs,
      size_t nbits);
 
  rvsdg::Node *
  ConvertICmpOp(
      ::mlir::LLVM::ICmpOp & operation,
      rvsdg::Region & rvsdgRegion,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs);
 
  rvsdg::Node *
  ConvertFPBinaryNode(
      const ::mlir::Operation & mlirOperation,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs);
 
  jlm::llvm::fpcmp
  TryConvertFPCMP(const ::mlir::arith::CmpFPredicate & op);
 
  rvsdg::Node *
  ConvertBitBinaryNode(
      ::mlir::Operation & mlirOperation,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs);
 
  std::vector<jlm::rvsdg::Output *>
  ConvertOperation(
      ::mlir::Operation & mlirOperation,
      rvsdg::Region & rvsdgRegion,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs);
 
  llvm::fpsize
  ConvertFPSize(unsigned int size);
 
  llvm::Linkage
  ConvertLinkage(std::string stringValue);
 
  std::unique_ptr<llvm::LlvmRvsdgModule>
  ConvertOmega(::mlir::rvsdg::OmegaNode & omegaNode);
 
  rvsdg::Node *
  ConvertLambda(
      ::mlir::Operation & mlirLambda,
      rvsdg::Region & rvsdgRegion,
      const ::llvm::SmallVector<rvsdg::Output *> & inputs);
 
  std::shared_ptr<const rvsdg::Type>
  ConvertType(const ::mlir::Type & type);
 
  static size_t
  GetIndexBitWidth()
  {
    // TODO
    // This should return an architeture dependent size
    // 32-bits are used for x86.
 
    return 32;
  }
 
  std::unique_ptr<::mlir::MLIRContext> Context_;
  util::BijectiveMap<::mlir::LLVM::LLVMStructType *, std::shared_ptr<const llvm::StructType>>
      StructTypeMap_;
};
 
} // namespace jlm::mlir
 
#endif // JLM_MLIR_FRONTEND_MLIRTOJLMCONVERTER_HPP