MlirToJlmConverter.cpp

Go to the documentation of this file.

/*
 * Copyright 2024 Louis Maurin <louis7maurin@gmail.com>
 * Copyright 2023 Magnus Sjalander <work@sjalander.com>
 * See COPYING for terms of redistribution.
 */
 
#include <jlm/llvm/ir/attribute.hpp>
#include <jlm/llvm/ir/operators/alloca.hpp>
#include <jlm/llvm/ir/operators/call.hpp>
#include <jlm/llvm/ir/operators/GetElementPtr.hpp>
#include <jlm/llvm/ir/operators/IntegerOperations.hpp>
#include <jlm/llvm/ir/operators/IOBarrier.hpp>
#include <jlm/llvm/ir/operators/Load.hpp>
#include <jlm/llvm/ir/operators/MemoryStateOperations.hpp>
#include <jlm/llvm/ir/operators/operators.hpp>
#include <jlm/llvm/ir/operators/sext.hpp>
#include <jlm/llvm/ir/operators/SpecializedArithmeticIntrinsicOperations.hpp>
#include <jlm/llvm/ir/operators/Store.hpp>
#include <jlm/mlir/frontend/MlirToJlmConverter.hpp>
#include <jlm/mlir/MLIRConverterCommon.hpp>
#include <jlm/rvsdg/bitstring/constant.hpp>
#include <jlm/rvsdg/FunctionType.hpp>
#include <mlir/Parser/Parser.h>
#include <mlir/Transforms/TopologicalSortUtils.h>
 
namespace jlm::mlir
{
 
std::unique_ptr<llvm::LlvmRvsdgModule>
MlirToJlmConverter::ReadAndConvertMlir(const util::FilePath & filePath)
{
  auto config = ::mlir::ParserConfig(Context_.get());
  std::unique_ptr<::mlir::Block> block = std::make_unique<::mlir::Block>();
  auto result = ::mlir::parseSourceFile(filePath.to_str(), block.get(), config);
  if (result.failed())
  {
    JLM_ASSERT("Parsing MLIR input file failed.");
  }
  return ConvertMlir(block);
}
 
std::unique_ptr<llvm::LlvmRvsdgModule>
MlirToJlmConverter::ConvertMlir(std::unique_ptr<::mlir::Block> & block)
{
  auto & topNode = block->front();
  if (auto module = ::mlir::dyn_cast<::mlir::ModuleOp>(topNode))
  {
    auto & newTopNode = module.getBodyRegion().front().front();
    auto omegaNode = ::mlir::dyn_cast<::mlir::rvsdg::OmegaNode>(newTopNode);
    if (!omegaNode)
    {
      JLM_UNREACHABLE("frontend : Top node in module op is not an OmegaNode.");
    }
    return ConvertOmega(omegaNode);
  }
  auto omegaNode = ::mlir::dyn_cast<::mlir::rvsdg::OmegaNode>(topNode);
  if (!omegaNode)
  {
    JLM_UNREACHABLE("frontend : Top node is not an OmegaNode.");
  }
  return ConvertOmega(omegaNode);
}
 
std::unique_ptr<llvm::LlvmRvsdgModule>
MlirToJlmConverter::ConvertOmega(::mlir::rvsdg::OmegaNode & omegaNode)
{
  auto rvsdgModule =
      llvm::LlvmRvsdgModule::Create(util::FilePath(""), std::string(), std::string());
  auto & graph = rvsdgModule->Rvsdg();
  auto & root = graph.GetRootRegion();
  ConvertRegion(omegaNode.getRegion(), root);
 
  return rvsdgModule;
}
 
::llvm::SmallVector<jlm::rvsdg::Output *>
MlirToJlmConverter::ConvertRegion(::mlir::Region & region, rvsdg::Region & rvsdgRegion)
{
  // MLIR use blocks as the innermost "container"
  // In the RVSDG Dialect a region should contain one and only one block
  JLM_ASSERT(region.getBlocks().size() == 1);
  return ConvertBlock(region.front(), rvsdgRegion);
}
 
::llvm::SmallVector<jlm::rvsdg::Output *>
MlirToJlmConverter::GetConvertedInputs(
    ::mlir::Operation & mlirOp,
    const std::unordered_map<void *, rvsdg::Output *> & outputMap)
{
  ::llvm::SmallVector<jlm::rvsdg::Output *> inputs;
  for (::mlir::Value operand : mlirOp.getOperands())
  {
    auto key = operand.getAsOpaquePointer();
    JLM_ASSERT(outputMap.find(key) != outputMap.end());
    inputs.push_back(outputMap.at(key));
  }
  return inputs;
}
 
::llvm::SmallVector<jlm::rvsdg::Output *>
MlirToJlmConverter::ConvertBlock(::mlir::Block & block, rvsdg::Region & rvsdgRegion)
{
  ::mlir::sortTopologically(&block);
 
  // Create an RVSDG node for each MLIR operation and store the mapping from
  // MLIR values to RVSDG outputs in a hash map for easy lookup
  std::unordered_map<void *, rvsdg::Output *> outputMap;
 
  for (size_t i = 0; i < block.getNumArguments(); i++)
  {
    auto arg = block.getArgument(i);
    auto key = arg.getAsOpaquePointer();
    outputMap[key] = rvsdgRegion.argument(i);
  }
 
  for (auto & mlirOp : block.getOperations())
  {
    if (auto argument = ::mlir::dyn_cast<::mlir::rvsdg::OmegaArgument>(mlirOp))
    {
      auto valueType = argument.getValueType();
      auto importedType = argument.getImportedValue().getType();
      auto jlmValueType = ConvertType(valueType);
      auto jlmImportedType = ConvertType(importedType);
 
      auto & jlmArgument = jlm::llvm::LlvmGraphImport::create(
          *rvsdgRegion.graph(),
          jlmValueType,
          jlmImportedType,
          argument.getNameAttr().cast<::mlir::StringAttr>().str(),
          llvm::linkageFromString(argument.getLinkageAttr().cast<::mlir::StringAttr>().str()),
          llvm::CallingConvention::Default, // FIXME: Currently not supported in MLIR dialect
          false,                            // FIXME: Currently not supported in MLIR dialect
          1);                               // FIXME: Currently not supported in MLIR dialect
 
      auto key = argument.getResult().getAsOpaquePointer();
      outputMap[key] = &jlmArgument;
    }
    else
    {
      ::llvm::SmallVector<jlm::rvsdg::Output *> inputs = GetConvertedInputs(mlirOp, outputMap);
 
      auto outputs = ConvertOperation(mlirOp, rvsdgRegion, inputs);
      JLM_ASSERT(outputs.size() == mlirOp.getNumResults());
      for (size_t i = 0; i < mlirOp.getNumResults(); i++)
      {
        auto result = mlirOp.getResult(i);
        auto key = result.getAsOpaquePointer();
        outputMap[key] = outputs[i];
      }
    }
  }
 
  // The results of the region/block are encoded in the terminator operation
  ::mlir::Operation * terminator = block.getTerminator();
 
  return GetConvertedInputs(*terminator, outputMap);
}
 
rvsdg::Node *
MlirToJlmConverter::ConvertCmpIOp(
    ::mlir::arith::CmpIOp & CompOp,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs,
    size_t nbits)
{
  if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::eq)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerEqOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::ne)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerNeOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::sge)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSgeOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::sgt)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSgtOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::sle)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSleOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::slt)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSltOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::uge)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerUgeOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::ugt)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerUgtOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::ule)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerUleOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else if (CompOp.getPredicate() == ::mlir::arith::CmpIPredicate::ult)
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerUltOperation>({ inputs[0], inputs[1] }, nbits);
  }
  else
  {
    JLM_UNREACHABLE("frontend : Unknown comparison predicate.");
  }
}
 
rvsdg::Node *
MlirToJlmConverter::ConvertICmpOp(
    ::mlir::LLVM::ICmpOp & operation,
    rvsdg::Region & rvsdgRegion,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs)
{
  if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::eq)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Eq);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::ne)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Ne);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::sge)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Sge);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::sgt)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Sgt);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::sle)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Sle);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else if (operation.getPredicate() == ::mlir::LLVM::ICmpPredicate::slt)
  {
    auto newOp = std::make_unique<llvm::PtrCmpOperation>(
        llvm::PointerType::Create(),
        llvm::ICmpPredicate::Slt);
    return &rvsdg::SimpleNode::Create(
        rvsdgRegion,
        std::move(newOp),
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()));
  }
  else
  {
    JLM_UNREACHABLE("MLIR frontend: Unknown pointer compare operation");
  }
}
 
rvsdg::Node *
MlirToJlmConverter::ConvertFPBinaryNode(
    const ::mlir::Operation & mlirOperation,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs)
{
  if (inputs.size() != 2)
    return nullptr;
  auto op = llvm::fpop::add;
  auto size = llvm::fpsize::half;
  if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::AddFOp>(&mlirOperation))
  {
    op = llvm::fpop::add;
    size = ConvertFPSize(castedOp.getType().cast<::mlir::FloatType>().getWidth());
  }
  else if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::SubFOp>(&mlirOperation))
  {
    op = llvm::fpop::sub;
    size = ConvertFPSize(castedOp.getType().cast<::mlir::FloatType>().getWidth());
  }
  else if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::MulFOp>(&mlirOperation))
  {
    op = llvm::fpop::mul;
    size = ConvertFPSize(castedOp.getType().cast<::mlir::FloatType>().getWidth());
  }
  else if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::DivFOp>(&mlirOperation))
  {
    op = llvm::fpop::div;
    size = ConvertFPSize(castedOp.getType().cast<::mlir::FloatType>().getWidth());
  }
  else if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::RemFOp>(&mlirOperation))
  {
    op = llvm::fpop::mod;
    size = ConvertFPSize(castedOp.getType().cast<::mlir::FloatType>().getWidth());
  }
  else
  {
    return nullptr;
  }
  return &rvsdg::CreateOpNode<llvm::FBinaryOperation>({ inputs[0], inputs[1] }, op, size);
}
 
llvm::fpcmp
MlirToJlmConverter::TryConvertFPCMP(const ::mlir::arith::CmpFPredicate & op)
{
  const auto & map = GetFpCmpPredicateMap();
  return map.LookupKey(op);
}
 
rvsdg::Node *
MlirToJlmConverter::ConvertBitBinaryNode(
    ::mlir::Operation & mlirOperation,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs)
{
  if (inputs.size() != 2 || mlirOperation.getNumResults() != 1)
    return nullptr;
 
  auto type = mlirOperation.getResult(0).getType();
 
  size_t width = 0;
  if (type.isa<::mlir::IntegerType>())
  {
    auto integerType = type.cast<::mlir::IntegerType>();
    width = integerType.getWidth();
  }
  else if (type.isIndex())
  {
    width = MlirToJlmConverter::GetIndexBitWidth();
  }
  else
  {
    return nullptr;
  }
 
  if (::mlir::isa<::mlir::arith::AddIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerAddOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::SubIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSubOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::MulIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerMulOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::DivSIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSDivOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::DivUIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerUDivOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::RemSIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerSRemOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::RemUIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerURemOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::LLVM::ShlOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerShlOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::LLVM::AShrOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerAShrOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::LLVM::LShrOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerLShrOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::AndIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerAndOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::OrIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerOrOperation>({ inputs[0], inputs[1] }, width);
  }
  else if (::mlir::isa<::mlir::arith::XOrIOp>(mlirOperation))
  {
    return &rvsdg::CreateOpNode<jlm::llvm::IntegerXorOperation>({ inputs[0], inputs[1] }, width);
  }
  else
  {
    return nullptr;
  }
}
 
static std::vector<llvm::MemoryNodeId>
arrayAttrToMemoryNodeIds(::mlir::ArrayAttr arrayAttr)
{
  std::vector<llvm::MemoryNodeId> memoryNodeIds;
  for (auto memoryNodeId : arrayAttr)
  {
    memoryNodeIds.push_back(memoryNodeId.cast<::mlir::IntegerAttr>().getInt());
  }
  return memoryNodeIds;
}
 
std::vector<jlm::rvsdg::Output *>
MlirToJlmConverter::ConvertOperation(
    ::mlir::Operation & mlirOperation,
    rvsdg::Region & rvsdgRegion,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs)
{
 
  // ** region Arithmetic Integer Operation **
  auto convertedBitBinaryNode = ConvertBitBinaryNode(mlirOperation, inputs);
  // If the operation was converted it means it has been casted to a bit binary operation
  if (convertedBitBinaryNode)
  {
    return rvsdg::outputs(convertedBitBinaryNode);
  }
  // ** endregion Arithmetic Integer Operation **
 
  // ** region Arithmetic Float Operation **
  auto convertedFloatBinaryNode = ConvertFPBinaryNode(mlirOperation, inputs);
  // If the operation was converted it means it has been casted to a fp binary operation
  if (convertedFloatBinaryNode)
  {
    return rvsdg::outputs(convertedFloatBinaryNode);
  }
 
  if (::mlir::isa<::mlir::LLVM::FMulAddOp>(&mlirOperation))
  {
    JLM_ASSERT(inputs.size() == 3);
    return rvsdg::outputs(
        &llvm::FMulAddIntrinsicOperation::CreateNode(*inputs[0], *inputs[1], *inputs[2]));
  }
  // ** endregion Arithmetic Float Operation **
 
  if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::ExtUIOp>(&mlirOperation))
  {
    auto st = std::dynamic_pointer_cast<const rvsdg::BitType>(inputs[0]->Type());
    if (!st)
      JLM_UNREACHABLE("Expected bitstring type for ExtUIOp operation.");
    ::mlir::Type type = castedOp.getType();
    return { &llvm::ZExtOperation::Create(*(inputs[0]), ConvertType(type)) };
  }
  else if (auto castedOp = ::mlir::dyn_cast<::mlir::arith::ExtSIOp>(&mlirOperation))
  {
    auto outputType = castedOp.getOut().getType();
    auto convertedOutputType = ConvertType(outputType);
    if (!::mlir::isa<::mlir::IntegerType>(castedOp.getType()))
      JLM_UNREACHABLE("Expected IntegerType for ExtSIOp operation output.");
    return { llvm::SExtOperation::create(
        castedOp.getType().cast<::mlir::IntegerType>().getWidth(),
        inputs[0]) };
  }
  else if (auto sitofpOp = ::mlir::dyn_cast<::mlir::arith::SIToFPOp>(&mlirOperation))
  {
    auto st = std::dynamic_pointer_cast<const jlm::rvsdg::BitType>(inputs[0]->Type());
    if (!st)
      JLM_UNREACHABLE("Expected bits type for SIToFPOp operation.");
 
    auto mlirOutputType = sitofpOp.getType();
    auto rt = ConvertType(mlirOutputType);
 
    return rvsdg::outputs(&rvsdg::CreateOpNode<llvm::SIToFPOperation>(
        std::vector<jlm::rvsdg::Output *>(inputs.begin(), inputs.end()),
        std::move(st),
        std::move(rt)));
  }
 
  else if (::mlir::isa<::mlir::rvsdg::OmegaNode>(&mlirOperation))
  {
    // Omega doesn't have a corresponding RVSDG node, so we return an empty vector
    return {};
  }
  else if (::mlir::isa<::mlir::rvsdg::LambdaNode>(&mlirOperation))
  {
    return rvsdg::outputs(ConvertLambda(mlirOperation, rvsdgRegion, inputs));
  }
  else if (auto callOp = ::mlir::dyn_cast<::mlir::jlm::Call>(&mlirOperation))
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> argumentTypes;
    for (auto arg : callOp.getArgs())
    {
      auto type = arg.getType();
      argumentTypes.push_back(ConvertType(type));
    }
    argumentTypes.push_back(llvm::IOStateType::Create());
    argumentTypes.push_back(llvm::MemoryStateType::Create());
 
    std::vector<std::shared_ptr<const rvsdg::Type>> resultTypes;
    for (auto res : callOp.getResults())
    {
      auto type = res.getType();
      resultTypes.push_back(ConvertType(type));
    }
 
    if (inputs.size() != 1 + argumentTypes.size())
      throw std::runtime_error("Function call should take target and parameters as input");
    const auto functionType = rvsdg::FunctionType::Create(argumentTypes, resultTypes);
 
    const auto target = inputs[0];
    const auto arguments = std::vector(std::next(inputs.begin()), inputs.end());
    return llvm::CallOperation::Create(
        target,
        std::move(functionType),
        llvm::CallingConvention::Default,       // FIXME: MLIR dialect does not support calling
                                                // conventions
        llvm::AttributeList::createEmptyList(), // FIXME: MLIR dialect does not support attributes
        arguments);
  }
  else if (auto constant = ::mlir::dyn_cast<::mlir::arith::ConstantIntOp>(&mlirOperation))
  {
    auto type = constant.getType();
    JLM_ASSERT(type.getTypeID() == ::mlir::IntegerType::getTypeID());
    auto integerType = ::mlir::cast<::mlir::IntegerType>(type);
 
    return rvsdg::outputs(&jlm::llvm::IntegerConstantOperation::Create(
        rvsdgRegion,
        integerType.getWidth(),
        constant.value()));
  }
  else if (auto constant = ::mlir::dyn_cast<::mlir::arith::ConstantFloatOp>(&mlirOperation))
  {
    auto type = constant.getType();
    if (!::mlir::isa<::mlir::FloatType>(type))
      JLM_UNREACHABLE("Expected FloatType for ConstantFloatOp operation.");
    auto floatType = ::mlir::cast<::mlir::FloatType>(type);
 
    auto size = ConvertFPSize(floatType.getWidth());
    return rvsdg::outputs(
        &rvsdg::CreateOpNode<llvm::ConstantFP>(rvsdgRegion, size, constant.value()));
  }
 
  // RVSDG does not have an index type. Indices are therefore converted to integers.
 
  else if (auto constant = ::mlir::dyn_cast<::mlir::arith::ConstantIndexOp>(&mlirOperation))
  {
    auto type = constant.getType();
    JLM_ASSERT(type.getTypeID() == ::mlir::IndexType::getTypeID());
 
    return rvsdg::outputs(&jlm::llvm::IntegerConstantOperation::Create(
        rvsdgRegion,
        MlirToJlmConverter::GetIndexBitWidth(),
        constant.value()));
  }
  else if (auto indexCast = ::mlir::dyn_cast<::mlir::arith::IndexCastOp>(&mlirOperation))
  {
    auto outputType = indexCast.getResult().getType();
    auto inputType = indexCast.getIn().getType();
    unsigned inputBits = inputType.getIntOrFloatBitWidth();
    unsigned outputBits = outputType.getIntOrFloatBitWidth();
 
    if (inputType.isIndex())
    {
      if (outputBits == MlirToJlmConverter::GetIndexBitWidth())
      {
        // Nothing is needed to be done so we simply pass on the inputs
        return { inputs.begin(), inputs.end() };
      }
      else if (outputBits > MlirToJlmConverter::GetIndexBitWidth())
      {
        return { llvm::SExtOperation::create(outputBits, inputs[0]) };
      }
      else
      {
        return { llvm::TruncOperation::create(outputBits, inputs[0]) };
      }
    }
    else
    {
      if (inputBits == MlirToJlmConverter::GetIndexBitWidth())
      {
        // Nothing to be done as indices are not supported and of default width
        return { inputs.begin(), inputs.end() };
      }
      else if (inputBits > MlirToJlmConverter::GetIndexBitWidth())
      {
        return { llvm::TruncOperation::create(MlirToJlmConverter::GetIndexBitWidth(), inputs[0]) };
      }
      else
      {
        return { &llvm::ZExtOperation::Create(
            *(inputs[0]),
            rvsdg::BitType::Create(MlirToJlmConverter::GetIndexBitWidth())) };
      }
    }
  }
 
  else if (auto negOp = ::mlir::dyn_cast<::mlir::arith::NegFOp>(&mlirOperation))
  {
    auto type = negOp.getResult().getType();
    auto floatType = ::mlir::cast<::mlir::FloatType>(type);
 
    llvm::fpsize size = ConvertFPSize(floatType.getWidth());
    return rvsdg::outputs(&rvsdg::CreateOpNode<jlm::llvm::FNegOperation>({ inputs[0] }, size));
  }
 
  else if (auto extOp = ::mlir::dyn_cast<::mlir::arith::ExtFOp>(&mlirOperation))
  {
    auto type = extOp.getResult().getType();
    auto floatType = ::mlir::cast<::mlir::FloatType>(type);
 
    llvm::fpsize size = ConvertFPSize(floatType.getWidth());
    return rvsdg::outputs(&rvsdg::CreateOpNode<jlm::llvm::FPExtOperation>(
        { inputs[0] },
        inputs[0]->Type(),
        llvm::FloatingPointType::Create(size)));
  }
 
  else if (auto truncOp = ::mlir::dyn_cast<::mlir::arith::TruncIOp>(&mlirOperation))
  {
    auto type = truncOp.getResult().getType();
    auto intType = ::mlir::cast<::mlir::IntegerType>(type);
    return { llvm::TruncOperation::create(intType.getIntOrFloatBitWidth(), inputs[0]) };
  }
  else if (auto constant = ::mlir::dyn_cast<::mlir::arith::ConstantFloatOp>(&mlirOperation))
  {
    auto type = constant.getType();
    auto floatType = ::mlir::cast<::mlir::FloatType>(type);
 
    llvm::fpsize size = ConvertFPSize(floatType.getWidth());
    return rvsdg::outputs(&rvsdg::CreateOpNode<jlm::llvm::ConstantFP>({}, size, constant.value()));
  }
 
  // Binary Integer Comparision operations
  else if (auto ComOp = ::mlir::dyn_cast<::mlir::arith::CmpIOp>(&mlirOperation))
  {
    auto type = ComOp.getOperandTypes()[0];
    if (type.isa<::mlir::IntegerType>())
    {
      auto integerType = ::mlir::cast<::mlir::IntegerType>(type);
      return rvsdg::outputs(ConvertCmpIOp(ComOp, inputs, integerType.getWidth()));
    }
    else if (type.isIndex())
    {
      return rvsdg::outputs(ConvertCmpIOp(ComOp, inputs, MlirToJlmConverter::GetIndexBitWidth()));
    }
    else
    {
      JLM_UNREACHABLE("Wrong type given to CmpIOp.");
    }
  }
 
  else if (auto ComOp = ::mlir::dyn_cast<::mlir::arith::CmpFOp>(&mlirOperation))
  {
    auto type = ComOp.getOperandTypes()[0];
    auto floatType = ::mlir::cast<::mlir::FloatType>(type);
    return rvsdg::outputs(&rvsdg::CreateOpNode<llvm::FCmpOperation>(
        std::vector(inputs.begin(), inputs.end()),
        TryConvertFPCMP(ComOp.getPredicate()),
        ConvertFPSize(floatType.getWidth())));
  }
 
  // Pointer compare is mapped to LLVM::ICmpOp
  else if (auto iComOp = ::mlir::dyn_cast<::mlir::LLVM::ICmpOp>(&mlirOperation))
  {
    return rvsdg::outputs(ConvertICmpOp(iComOp, rvsdgRegion, inputs));
  }
 
  else if (auto UndefOp = ::mlir::dyn_cast<::mlir::jlm::Undef>(&mlirOperation))
  {
    auto type = UndefOp.getResult().getType();
    auto jlmType = ConvertType(type);
    return { jlm::llvm::UndefValueOperation::Create(rvsdgRegion, jlmType) };
  }
 
  else if (auto ArrayOp = ::mlir::dyn_cast<::mlir::jlm::ConstantDataArray>(&mlirOperation))
  {
    return { llvm::ConstantDataArray::Create(std::vector(inputs.begin(), inputs.end())) };
  }
 
  else if (auto ZeroOp = ::mlir::dyn_cast<::mlir::LLVM::ZeroOp>(&mlirOperation))
  {
    auto type = ZeroOp.getType();
    // NULL pointers are a special case of ZeroOp
    if (::mlir::isa<::mlir::LLVM::LLVMPointerType>(type))
    {
      return { llvm::ConstantPointerNullOperation::Create(&rvsdgRegion, ConvertType(type)) };
    }
    return { llvm::ConstantAggregateZeroOperation::Create(rvsdgRegion, ConvertType(type)) };
  }
 
  else if (auto VarArgOp = ::mlir::dyn_cast<::mlir::jlm::CreateVarArgList>(&mlirOperation))
  {
    return { llvm::VariadicArgumentListOperation::Create(
        rvsdgRegion,
        std::vector(inputs.begin(), inputs.end())) };
  }
 
  // Memory operations
 
  else if (auto FreeOp = ::mlir::dyn_cast<::mlir::jlm::Free>(&mlirOperation))
  {
    return rvsdg::outputs(&rvsdg::CreateOpNode<llvm::FreeOperation>(
        std::vector(inputs.begin(), inputs.end()),
        inputs.size() - 2));
  }
 
  else if (auto AllocaOp = ::mlir::dyn_cast<::mlir::jlm::Alloca>(&mlirOperation))
  {
    auto outputType = AllocaOp.getValueType();
 
    auto jlmType = ConvertType(outputType);
    if (jlmType->Kind() != rvsdg::TypeKind::Value)
      JLM_UNREACHABLE("Expected ValueType for AllocaOp operation.");
 
    if (!rvsdg::is<const rvsdg::BitType>(inputs[0]->Type()))
      JLM_UNREACHABLE("Expected BitType for AllocaOp operation.");
 
    auto jlmBitType = std::dynamic_pointer_cast<const jlm::rvsdg::BitType>(inputs[0]->Type());
 
    return rvsdg::outputs(&rvsdg::CreateOpNode<llvm::AllocaOperation>(
        std::vector(inputs.begin(), inputs.end()),
        jlmType,
        jlmBitType,
        AllocaOp.getAlignment()));
  }
  else if (auto MemstateMergeOp = ::mlir::dyn_cast<::mlir::rvsdg::MemStateMerge>(&mlirOperation))
  {
    auto operands = std::vector(inputs.begin(), inputs.end());
    return { jlm::llvm::MemoryStateMergeOperation::Create(operands) };
  }
  else if (
      auto LambdaEntryMemstateSplitOp =
          ::mlir::dyn_cast<::mlir::rvsdg::LambdaEntryMemoryStateSplit>(&mlirOperation))
  {
    auto memoryNodeIds =
        arrayAttrToMemoryNodeIds(LambdaEntryMemstateSplitOp.getMemoryStateIndices());
 
    auto operands = std::vector(inputs.begin(), inputs.end());
    return outputs(&jlm::llvm::LambdaEntryMemoryStateSplitOperation::CreateNode(
        *operands.front(),
        std::move(memoryNodeIds)));
  }
  if (auto LambdaExitMemstateMergeOp =
          ::mlir::dyn_cast<::mlir::rvsdg::LambdaExitMemoryStateMerge>(&mlirOperation))
  {
    auto memoryNodeIds =
        arrayAttrToMemoryNodeIds(LambdaExitMemstateMergeOp.getMemoryStateIndices());
 
    auto operands = std::vector(inputs.begin(), inputs.end());
    return rvsdg::outputs(&jlm::llvm::LambdaExitMemoryStateMergeOperation::CreateNode(
        rvsdgRegion,
        operands,
        std::move(memoryNodeIds)));
  }
  else if (
      auto CallEntryMemstateMergeOp =
          ::mlir::dyn_cast<::mlir::rvsdg::CallEntryMemoryStateMerge>(&mlirOperation))
  {
    auto memoryNodeIds = arrayAttrToMemoryNodeIds(CallEntryMemstateMergeOp.getMemoryStateIndices());
 
    auto operands = std::vector(inputs.begin(), inputs.end());
    return rvsdg::outputs(&jlm::llvm::CallEntryMemoryStateMergeOperation::CreateNode(
        rvsdgRegion,
        operands,
        std::move(memoryNodeIds)));
  }
  else if (
      auto CallExitMemstateSplitOp =
          ::mlir::dyn_cast<::mlir::rvsdg::CallExitMemoryStateSplit>(&mlirOperation))
  {
    auto memoryNodeIds = arrayAttrToMemoryNodeIds(CallExitMemstateSplitOp.getMemoryStateIndices());
 
    auto operands = std::vector(inputs.begin(), inputs.end());
    return rvsdg::outputs(&jlm::llvm::CallExitMemoryStateSplitOperation::CreateNode(
        *operands.front(),
        std::move(memoryNodeIds)));
  }
  else if (::mlir::isa<::mlir::rvsdg::MemoryStateJoin>(&mlirOperation))
  {
    std::vector operands(inputs.begin(), inputs.end());
    return rvsdg::outputs(&llvm::MemoryStateJoinOperation::CreateNode(operands));
  }
  else if (auto IOBarrierOp = ::mlir::dyn_cast<::mlir::jlm::IOBarrier>(&mlirOperation))
  {
    auto type = IOBarrierOp.getResult().getType();
    return rvsdg::outputs(&rvsdg::CreateOpNode<llvm::IOBarrierOperation>(
        std::vector(inputs.begin(), inputs.end()),
        ConvertType(type)));
  }
  else if (auto MallocOp = ::mlir::dyn_cast<::mlir::jlm::Malloc>(&mlirOperation))
  {
    return outputs(&llvm::MallocOperation::createNode(*inputs[0], *inputs[1]));
  }
  else if (auto StoreOp = ::mlir::dyn_cast<::mlir::jlm::Store>(&mlirOperation))
  {
    auto address = inputs[0];
    auto value = inputs[1];
    auto memoryStateInputs = std::vector(std::next(inputs.begin(), 2), inputs.end());
    return rvsdg::outputs(&jlm::llvm::StoreNonVolatileOperation::CreateNode(
        *address,
        *value,
        memoryStateInputs,
        StoreOp.getAlignment()));
  }
  else if (auto LoadOp = ::mlir::dyn_cast<::mlir::jlm::Load>(&mlirOperation))
  {
    auto address = inputs[0];
    auto memoryStateInputs = std::vector(std::next(inputs.begin()), inputs.end());
    auto outputType = LoadOp.getOutput().getType();
    auto jlmType = ConvertType(outputType);
    if (jlmType->Kind() != rvsdg::TypeKind::Value)
      JLM_UNREACHABLE("Expected ValueType for LoadOp operation output.");
    return rvsdg::outputs(&llvm::LoadNonVolatileOperation::CreateNode(
        *address,
        memoryStateInputs,
        jlmType,
        LoadOp.getAlignment()));
  }
  else if (auto GepOp = ::mlir::dyn_cast<::mlir::LLVM::GEPOp>(&mlirOperation))
  {
    auto elemType = GepOp.getElemType();
    auto pointeeType = ConvertType(elemType);
    if (pointeeType->Kind() != rvsdg::TypeKind::Value)
      JLM_UNREACHABLE("Expected ValueType for GepOp operation pointee.");
 
    std::vector<rvsdg::Output *> indices;
    // The first input is the base pointer
    size_t dynamicInput = 1;
    for (int32_t constant : GepOp.getRawConstantIndices())
    {
      // If magic number then its a dynamic index
      if (constant == ::mlir::LLVM::GEPOp::kDynamicIndex)
      {
        indices.push_back(inputs[dynamicInput++]);
      }
      else
      {
        // Constant indices are not part of the inputs to a GEPOp,
        // but they are required as explicit nodes in RVSDG
        indices.push_back(
            jlm::llvm::IntegerConstantOperation::Create(rvsdgRegion, 32, constant).output(0));
      }
    }
 
    return { llvm::GetElementPtrOperation::create(inputs[0], indices, pointeeType) };
  }
  // * region Structural nodes **
  else if (auto MlirCtrlConst = ::mlir::dyn_cast<::mlir::rvsdg::ConstantCtrl>(&mlirOperation))
  {
    JLM_ASSERT(::mlir::isa<::mlir::rvsdg::RVSDG_CTRLType>(MlirCtrlConst.getType()));
    return { &rvsdg::ControlConstantOperation::create(
        rvsdgRegion,
        ::mlir::cast<::mlir::rvsdg::RVSDG_CTRLType>(MlirCtrlConst.getType()).getNumOptions(),
        MlirCtrlConst.getValue()) };
  }
  else if (auto mlirGammaNode = ::mlir::dyn_cast<::mlir::rvsdg::GammaNode>(&mlirOperation))
  {
    auto rvsdgGammaNode = rvsdg::GammaNode::create(
        inputs[0],                    // predicate
        mlirGammaNode.getNumRegions() // nalternatives
    );
 
    // Add inputs to the gamma node and to all it's subregions
    for (size_t i = 1; i < inputs.size(); i++)
    {
      rvsdgGammaNode->AddEntryVar(inputs[i]);
    }
 
    ::llvm::SmallVector<::llvm::SmallVector<jlm::rvsdg::Output *>> regionResults;
    for (size_t i = 0; i < mlirGammaNode.getNumRegions(); i++)
    {
      regionResults.push_back(
          ConvertRegion(mlirGammaNode.getRegion(i), *rvsdgGammaNode->subregion(i)));
    }
 
    // Connect the outputs
    for (size_t exitvarIndex = 0; exitvarIndex < regionResults[0].size(); exitvarIndex++)
    {
      std::vector<rvsdg::Output *> exitvars;
      for (size_t regionIndex = 0; regionIndex < mlirGammaNode.getNumRegions(); regionIndex++)
      {
        JLM_ASSERT(regionResults[regionIndex].size() == regionResults[0].size());
        exitvars.push_back(regionResults[regionIndex][exitvarIndex]);
      }
      rvsdgGammaNode->AddExitVar(exitvars);
    }
 
    return rvsdg::outputs(rvsdgGammaNode);
  }
  else if (auto mlirThetaNode = ::mlir::dyn_cast<::mlir::rvsdg::ThetaNode>(&mlirOperation))
  {
    auto rvsdgThetaNode = rvsdg::ThetaNode::create(&rvsdgRegion);
 
    // Add loop vars to the theta node
    for (size_t i = 0; i < inputs.size(); i++)
    {
      rvsdgThetaNode->AddLoopVar(inputs[i]);
    }
 
    auto regionResults = ConvertRegion(mlirThetaNode.getRegion(), *rvsdgThetaNode->subregion());
 
    rvsdgThetaNode->set_predicate(regionResults[0]);
 
    auto loopvars = rvsdgThetaNode->GetLoopVars();
    for (size_t i = 1; i < regionResults.size(); i++)
    {
      loopvars[i - 1].post->divert_to(regionResults[i]);
    }
 
    return rvsdg::outputs(rvsdgThetaNode);
  }
  else if (auto mlirDeltaNode = ::mlir::dyn_cast<::mlir::rvsdg::DeltaNode>(&mlirOperation))
  {
    auto & deltaRegion = mlirDeltaNode.getRegion();
    auto & deltaBlock = deltaRegion.front();
    auto terminator = deltaBlock.getTerminator();
 
    auto mlirOutputType = terminator->getOperand(0).getType();
    auto outputType = ConvertType(mlirOutputType);
    auto linakgeString = mlirDeltaNode.getLinkage().str();
    auto rvsdgDeltaNode = rvsdg::DeltaNode::Create(
        &rvsdgRegion,
        llvm::DeltaOperation::Create(
            outputType,
            mlirDeltaNode.getName().str(),
            ConvertLinkage(linakgeString),
            mlirDeltaNode.getSection().str(),
            mlirDeltaNode.getConstant(),
            4)); // FIXME: the MLIR delta node does not support the alignment attribute
 
    auto outputVector = ConvertRegion(mlirDeltaNode.getRegion(), *rvsdgDeltaNode->subregion());
 
    if (outputVector.size() != 1)
      JLM_UNREACHABLE("Expected 1 output for Delta operation.");
 
    rvsdgDeltaNode->finalize(outputVector[0]);
 
    return rvsdg::outputs(rvsdgDeltaNode);
  }
  else if (auto mlirMatch = ::mlir::dyn_cast<::mlir::rvsdg::Match>(&mlirOperation))
  {
    std::unordered_map<uint64_t, uint64_t> mapping;
    uint64_t defaultAlternative = 0;
    for (auto & attr : mlirMatch.getMapping())
    {
      JLM_ASSERT(attr.isa<::mlir::rvsdg::MatchRuleAttr>());
      auto matchRuleAttr = attr.cast<::mlir::rvsdg::MatchRuleAttr>();
      if (matchRuleAttr.isDefault())
      {
        defaultAlternative = matchRuleAttr.getIndex();
        continue;
      }
      // In our Mlir implementation, an index is associated with a single value
      mapping[matchRuleAttr.getValues().front()] = matchRuleAttr.getIndex();
    }
 
    return { rvsdg::MatchOperation::Create(
        *(inputs[0]),                 // predicate
        mapping,                      // mapping
        defaultAlternative,           // defaultAlternative
        mlirMatch.getMapping().size() // numAlternatives
        ) };
  }
  else if (auto selectOp = ::mlir::dyn_cast<::mlir::arith::SelectOp>(&mlirOperation))
  {
    auto type = selectOp.getType();
    auto jlmType = ConvertType(type);
    return rvsdg::outputs(&rvsdg::CreateOpNode<jlm::llvm::SelectOperation>(
        std::vector(inputs.begin(), inputs.end()),
        jlmType));
  }
  else if (auto mlirOmegaResult = ::mlir::dyn_cast<::mlir::rvsdg::OmegaResult>(&mlirOperation))
  {
    for (auto input : inputs)
    {
      auto origin = rvsdg::TryGetOwnerNode<rvsdg::Node>(*input);
      if (auto lambda = dynamic_cast<rvsdg::LambdaNode *>(origin))
      {
        auto op = dynamic_cast<llvm::LlvmLambdaOperation *>(&lambda->GetOperation());
        jlm::rvsdg::GraphExport::Create(*input, op->name());
      }
      else if (auto delta = dynamic_cast<rvsdg::DeltaNode *>(origin))
      {
        auto op = util::assertedCast<const llvm::DeltaOperation>(&delta->GetOperation());
        jlm::rvsdg::GraphExport::Create(*input, op->name());
      }
    }
    return {};
  }
  // ** endregion Structural nodes **
 
  else if (
      ::mlir::isa<::mlir::rvsdg::LambdaResult>(&mlirOperation)
      || ::mlir::isa<::mlir::rvsdg::GammaResult>(&mlirOperation)
      || ::mlir::isa<::mlir::rvsdg::ThetaResult>(&mlirOperation)
      || ::mlir::isa<::mlir::rvsdg::DeltaResult>(&mlirOperation)
      // This is a terminating operation that doesn't have a corresponding RVSDG node
      || ::mlir::isa<::mlir::rvsdg::OmegaArgument>(&mlirOperation)) // Handled at the top level
  {
    return {};
  }
  else
  {
    mlirOperation.dump();
    auto message = util::strfmt(
        "Operation not implemented: ",
        mlirOperation.getName().getStringRef().str(),
        "\n");
    JLM_UNREACHABLE(message.c_str());
  }
}
 
llvm::fpsize
MlirToJlmConverter::ConvertFPSize(unsigned int size)
{
  switch (size)
  {
  case 16:
    return llvm::fpsize::half;
  case 32:
    return llvm::fpsize::flt;
  case 64:
    return llvm::fpsize::dbl;
  case 80:
    return llvm::fpsize::x86fp80;
  case 128:
    return llvm::fpsize::fp128;
  default:
    auto message = util::strfmt("Unsupported floating point size: ", size, "\n");
    JLM_UNREACHABLE(message.c_str());
    break;
  }
}
 
llvm::Linkage
MlirToJlmConverter::ConvertLinkage(std::string stringValue)
{
  if (!stringValue.compare("external_linkage"))
  {
    return llvm::Linkage::externalLinkage;
  }
  else if (!stringValue.compare("available_externally_linkage"))
  {
    return llvm::Linkage::availableExternallyLinkage;
  }
  else if (!stringValue.compare("link_once_any_linkage"))
  {
    return llvm::Linkage::linkOnceAnyLinkage;
  }
  else if (!stringValue.compare("link_once_odr_linkage"))
  {
    return llvm::Linkage::linkOnceOdrLinkage;
  }
  else if (!stringValue.compare("weak_any_linkage"))
  {
    return llvm::Linkage::weakAnyLinkage;
  }
  else if (!stringValue.compare("weak_odr_linkage"))
  {
    return llvm::Linkage::weakOdrLinkage;
  }
  else if (!stringValue.compare("appending_linkage"))
  {
    return llvm::Linkage::appendingLinkage;
  }
  else if (!stringValue.compare("internal_linkage"))
  {
    return llvm::Linkage::internalLinkage;
  }
  else if (!stringValue.compare("private_linkage"))
  {
    return llvm::Linkage::privateLinkage;
  }
  else if (!stringValue.compare("external_weak_linkage"))
  {
    return llvm::Linkage::externalWeakLinkage;
  }
  else if (!stringValue.compare("common_linkage"))
  {
    return llvm::Linkage::commonLinkage;
  }
  auto message = util::strfmt("Unsupported linkage: ", stringValue, "\n");
  JLM_UNREACHABLE(message.c_str());
}
 
jlm::rvsdg::Node *
MlirToJlmConverter::ConvertLambda(
    ::mlir::Operation & mlirOperation,
    rvsdg::Region & rvsdgRegion,
    const ::llvm::SmallVector<rvsdg::Output *> & inputs)
{
  // Get the name of the function
  auto functionNameAttribute = mlirOperation.getAttr(::llvm::StringRef("sym_name"));
  JLM_ASSERT(functionNameAttribute != nullptr);
  auto functionName = ::mlir::cast<::mlir::StringAttr>(functionNameAttribute);
 
  auto lambdaOp = ::mlir::dyn_cast<::mlir::rvsdg::LambdaNode>(&mlirOperation);
  auto & lambdaRegion = lambdaOp.getRegion();
  auto numNonContextVars = lambdaRegion.getNumArguments() - lambdaOp.getNumOperands();
  auto & lambdaBlock = lambdaRegion.front();
  auto lamdbaTerminator = lambdaBlock.getTerminator();
 
  // Create the RVSDG function signature
  std::vector<std::shared_ptr<const rvsdg::Type>> argumentTypes;
  for (size_t argumentIndex = 0; argumentIndex < numNonContextVars; argumentIndex++)
  {
    auto type = lambdaRegion.getArgument(argumentIndex).getType();
    argumentTypes.push_back(ConvertType(type));
  }
  std::vector<std::shared_ptr<const rvsdg::Type>> resultTypes;
  for (auto returnType : lamdbaTerminator->getOperandTypes())
  {
    resultTypes.push_back(ConvertType(returnType));
  }
  auto functionType = rvsdg::FunctionType::Create(std::move(argumentTypes), std::move(resultTypes));
 
  // FIXME
  // The linkage should be part of the MLIR attributes so it can be extracted here
  auto rvsdgLambda = rvsdg::LambdaNode::Create(
      rvsdgRegion,
      llvm::LlvmLambdaOperation::Create(
          functionType,
          functionName.getValue().str(),
          llvm::Linkage::externalLinkage));
 
  for (auto input : inputs)
  {
    rvsdgLambda->AddContextVar(*input);
  }
 
  auto jlmLambdaRegion = rvsdgLambda->subregion();
  auto regionResults = ConvertRegion(lambdaRegion, *jlmLambdaRegion);
 
  rvsdgLambda->finalize(std::vector<rvsdg::Output *>(regionResults.begin(), regionResults.end()));
 
  return rvsdgLambda;
}
 
std::shared_ptr<const rvsdg::Type>
MlirToJlmConverter::ConvertType(const ::mlir::Type & type)
{
  if (auto ctrlType = ::mlir::dyn_cast<::mlir::rvsdg::RVSDG_CTRLType>(type))
  {
    return rvsdg::ControlType::Create(ctrlType.getNumOptions());
  }
  else if (auto intType = ::mlir::dyn_cast<::mlir::IntegerType>(type))
  {
    return rvsdg::BitType::Create(intType.getWidth());
  }
  else if (::mlir::isa<::mlir::Float16Type>(type))
  {
    return llvm::FloatingPointType::Create(llvm::fpsize::half);
  }
  else if (::mlir::isa<::mlir::Float32Type>(type))
  {
    return llvm::FloatingPointType::Create(llvm::fpsize::flt);
  }
  else if (::mlir::isa<::mlir::Float64Type>(type))
  {
    return llvm::FloatingPointType::Create(llvm::fpsize::dbl);
  }
  else if (::mlir::isa<::mlir::Float80Type>(type))
  {
    return llvm::FloatingPointType::Create(llvm::fpsize::x86fp80);
  }
  else if (::mlir::isa<::mlir::Float128Type>(type))
  {
    return llvm::FloatingPointType::Create(llvm::fpsize::fp128);
  }
  else if (::mlir::isa<::mlir::rvsdg::MemStateEdgeType>(type))
  {
    return llvm::MemoryStateType::Create();
  }
  else if (::mlir::isa<::mlir::rvsdg::IOStateEdgeType>(type))
  {
    return llvm::IOStateType::Create();
  }
  else if (::mlir::isa<::mlir::LLVM::LLVMPointerType>(type))
  {
    return llvm::PointerType::Create();
  }
  else if (::mlir::isa<::mlir::jlm::VarargListType>(type))
  {
    return llvm::VariableArgumentType::Create();
  }
  else if (auto arrayType = ::mlir::dyn_cast<::mlir::LLVM::LLVMArrayType>(type))
  {
    auto mlirElementType = arrayType.getElementType();
    std::shared_ptr<const rvsdg::Type> elementType = ConvertType(mlirElementType);
    return llvm::ArrayType::Create(elementType, arrayType.getNumElements());
  }
  else if (auto functionType = ::mlir::dyn_cast<::mlir::FunctionType>(type))
  {
    std::vector<std::shared_ptr<const rvsdg::Type>> argumentTypes;
    for (auto argumentType : functionType.getInputs())
    {
      argumentTypes.push_back(ConvertType(argumentType));
    }
    std::vector<std::shared_ptr<const rvsdg::Type>> resultTypes;
    for (auto resultType : functionType.getResults())
    {
      resultTypes.push_back(ConvertType(resultType));
    }
    return rvsdg::FunctionType::Create(argumentTypes, resultTypes);
  }
  else if (type.isIndex())
  {
    // RVSDG does not support indices, which are modeled as integers
    return rvsdg::BitType::Create(MlirToJlmConverter::GetIndexBitWidth());
  }
  else if (auto structType = ::mlir::dyn_cast<::mlir::LLVM::LLVMStructType>(type))
  {
    if (StructTypeMap_.HasKey(&structType))
    {
      return StructTypeMap_.LookupKey(&structType);
    }
 
    std::vector<std::shared_ptr<const rvsdg::Type>> types;
    for (auto element : structType.getBody())
    {
      types.push_back(ConvertType(element));
    }
 
    std::shared_ptr<const llvm::StructType> jlmStructType;
    if (structType.isIdentified())
    {
      jlmStructType = jlm::llvm::StructType::CreateIdentified(
          structType.getName().str(),
          types,
          structType.isPacked());
    }
    else
    {
      jlmStructType = jlm::llvm::StructType::CreateLiteral(types, structType.isPacked());
    }
 
    StructTypeMap_.Insert(&structType, jlmStructType);
    return jlmStructType;
  }
  else
  {
    type.dump();
    JLM_UNREACHABLE("Type conversion not implemented\n");
  }
}
 
} // jlm::mlirrvsdg