StdLibIntrinsicOperations.hpp

Go to the documentation of this file.

/*
 * Copyright 2024 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_IR_OPERATORS_STDLIBINTRINSICOPERATIONS_HPP
#define JLM_LLVM_IR_OPERATORS_STDLIBINTRINSICOPERATIONS_HPP
 
#include <jlm/llvm/ir/tac.hpp>
#include <jlm/llvm/ir/types.hpp>
#include <jlm/rvsdg/bitstring.hpp>
#include <jlm/rvsdg/simple-node.hpp>
 
namespace jlm::llvm
{
 
class MemCpyOperation : public rvsdg::SimpleOperation
{
protected:
  MemCpyOperation(
      const std::vector<std::shared_ptr<const rvsdg::Type>> & operandTypes,
      const std::vector<std::shared_ptr<const rvsdg::Type>> & resultTypes)
      : SimpleOperation(operandTypes, resultTypes)
  {
    JLM_ASSERT(operandTypes.size() >= 3);
 
    auto & dstAddressType = *operandTypes[0];
    JLM_ASSERT(is<PointerType>(dstAddressType));
 
    auto & srcAddressType = *operandTypes[1];
    JLM_ASSERT(is<PointerType>(srcAddressType));
 
    auto & lengthType = *operandTypes[2];
    if (lengthType != *rvsdg::BitType::Create(32) && lengthType != *rvsdg::BitType::Create(64))
    {
      throw util::Error("Expected 32 bit or 64 bit integer type.");
    }
  }
 
public:
  [[nodiscard]] const rvsdg::BitType &
  LengthType() const noexcept
  {
    auto type = std::dynamic_pointer_cast<const rvsdg::BitType>(argument(2));
    JLM_ASSERT(type != nullptr);
    return *type;
  }
 
  [[nodiscard]] virtual size_t
  NumMemoryStates() const noexcept = 0;
 
  [[nodiscard]] static rvsdg::Input &
  destinationInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemCpyOperation>(&node));
    const auto input = node.input(0);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  sourceInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemCpyOperation>(&node));
    const auto input = node.input(1);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  countInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemCpyOperation>(&node));
    const auto input = node.input(2);
    JLM_ASSERT(is<rvsdg::BitType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  mapMemoryStateOutputToInput(const rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [memCpyNode, memCpyOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemCpyOperation>(output);
    JLM_ASSERT(memCpyOperation);
    const auto numNonMemoryStateOutputs =
        memCpyNode->noutputs() - memCpyOperation->NumMemoryStates();
    JLM_ASSERT(output.index() >= numNonMemoryStateOutputs);
    const auto numNonMemoryStateInputs = memCpyNode->ninputs() - memCpyOperation->NumMemoryStates();
    const auto inputIndex = numNonMemoryStateInputs + (output.index() - numNonMemoryStateOutputs);
    const auto input = memCpyNode->input(inputIndex);
    JLM_ASSERT(is<MemoryStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  mapMemoryStateInputToOutput(const rvsdg::Input & input)
  {
    JLM_ASSERT(is<MemoryStateType>(input.Type()));
    auto [memCpyNode, memCpyOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemCpyOperation>(input);
    JLM_ASSERT(memCpyOperation);
    const auto numNonMemoryStateInputs = memCpyNode->ninputs() - memCpyOperation->NumMemoryStates();
    JLM_ASSERT(input.index() >= numNonMemoryStateInputs);
    const auto numNonMemoryStateOutputs =
        memCpyNode->noutputs() - memCpyOperation->NumMemoryStates();
    const auto outputIndex = numNonMemoryStateOutputs + (input.index() - numNonMemoryStateInputs);
    const auto output = memCpyNode->output(outputIndex);
    JLM_ASSERT(is<MemoryStateType>(output->Type()));
    return *output;
  }
 
  [[nodiscard]] static rvsdg::Node::OutputIteratorRange
  memoryStateOutputs(const rvsdg::Node & node) noexcept
  {
    const auto memCpyOperation = util::assertedCast<const MemCpyOperation>(&node.GetOperation());
    if (memCpyOperation->NumMemoryStates() == 0)
    {
      return { rvsdg::Output::Iterator(nullptr), rvsdg::Output::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.output(memCpyOperation->nresults() - memCpyOperation->NumMemoryStates());
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Output::Iterator(firstMemoryStateOutput), rvsdg::Output::Iterator(nullptr) };
  }
};
 
class MemCpyNonVolatileOperation final : public MemCpyOperation
{
public:
  ~MemCpyNonVolatileOperation() override;
 
  MemCpyNonVolatileOperation(std::shared_ptr<const rvsdg::Type> lengthType, size_t numMemoryStates)
      : MemCpyOperation(
            CreateOperandTypes(std::move(lengthType), numMemoryStates),
            CreateResultTypes(numMemoryStates))
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] size_t
  NumMemoryStates() const noexcept override;
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  create(
      const Variable * destination,
      const Variable * source,
      const Variable * length,
      const std::vector<const Variable *> & memoryStates)
  {
    std::vector<const Variable *> operands = { destination, source, length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation =
        std::make_unique<MemCpyNonVolatileOperation>(length->Type(), memoryStates.size());
    return ThreeAddressCode::create(std::move(operation), operands);
  }
 
  static rvsdg::SimpleNode &
  createNode(
      rvsdg::Output & destination,
      rvsdg::Output & source,
      rvsdg::Output & length,
      const std::vector<rvsdg::Output *> & memoryStates)
  {
    std::vector operands = { &destination, &source, &length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    return rvsdg::CreateOpNode<MemCpyNonVolatileOperation>(
        operands,
        length.Type(),
        memoryStates.size());
  }
 
  static std::vector<rvsdg::Output *>
  create(
      rvsdg::Output * destination,
      rvsdg::Output * source,
      rvsdg::Output * length,
      const std::vector<rvsdg::Output *> & memoryStates)
  {
    std::vector operands = { destination, source, length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    return outputs(&rvsdg::CreateOpNode<MemCpyNonVolatileOperation>(
        operands,
        length->Type(),
        memoryStates.size()));
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(std::shared_ptr<const rvsdg::Type> length, size_t numMemoryStates)
  {
    auto pointerType = PointerType::Create();
    std::vector<std::shared_ptr<const rvsdg::Type>> types = { pointerType, pointerType, length };
    types.insert(types.end(), numMemoryStates, MemoryStateType::Create());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateResultTypes(size_t numMemoryStates)
  {
    // The memcpy() standard C library call has as return type void*, but LLVM models the
    // function call nevertheless as:
    // call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %8, i64 %9, i1 false)
    //
    // LLVM simply hands in register %7 (dest pointer) to all users of the return type of memcpy().
    // Thus, we only need state types as result types of the operation here.
    return { numMemoryStates, MemoryStateType::Create() };
  }
};
 
class MemCpyVolatileOperation final : public MemCpyOperation
{
public:
  ~MemCpyVolatileOperation() noexcept override;
 
  MemCpyVolatileOperation(std::shared_ptr<const rvsdg::Type> lengthType, size_t numMemoryStates)
      : MemCpyOperation(
            CreateOperandTypes(std::move(lengthType), numMemoryStates),
            CreateResultTypes(numMemoryStates))
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] size_t
  NumMemoryStates() const noexcept override;
 
  [[nodiscard]] static rvsdg::Input &
  getIOStateInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemCpyVolatileOperation>(&node));
    const auto input = node.input(3);
    JLM_ASSERT(is<IOStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  getIOStateOutput(const rvsdg::Node & node)
  {
    JLM_ASSERT(is<MemCpyVolatileOperation>(&node));
    const auto output = node.output(0);
    JLM_ASSERT(is<IOStateType>(output->Type()));
    return *output;
  }
 
  static std::unique_ptr<llvm::ThreeAddressCode>
  CreateThreeAddressCode(
      const Variable & destination,
      const Variable & source,
      const Variable & length,
      const Variable & ioState,
      const std::vector<const Variable *> & memoryStates)
  {
    std::vector<const Variable *> operands = { &destination, &source, &length, &ioState };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation = std::make_unique<MemCpyVolatileOperation>(length.Type(), memoryStates.size());
    return ThreeAddressCode::create(std::move(operation), operands);
  }
 
  static rvsdg::SimpleNode &
  CreateNode(
      rvsdg::Output & destination,
      rvsdg::Output & source,
      rvsdg::Output & length,
      rvsdg::Output & ioState,
      const std::vector<rvsdg::Output *> & memoryStates)
  {
    std::vector operands = { &destination, &source, &length, &ioState };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    return rvsdg::CreateOpNode<MemCpyVolatileOperation>(
        operands,
        length.Type(),
        memoryStates.size());
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateOperandTypes(std::shared_ptr<const rvsdg::Type> lengthType, size_t numMemoryStates)
  {
    auto pointerType = PointerType::Create();
    std::vector<std::shared_ptr<const rvsdg::Type>> types = { pointerType,
                                                              pointerType,
                                                              std::move(lengthType),
                                                              IOStateType::Create() };
    types.insert(types.end(), numMemoryStates, MemoryStateType::Create());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  CreateResultTypes(size_t numMemoryStates)
  {
    // The memcpy() standard C library call has as return type void*, but LLVM models the
    // function call nevertheless as:
    // call void @llvm.memcpy.p0.p0.i64(ptr align 4 %7, ptr align 4 %8, i64 %9, i1 false)
    //
    // LLVM simply hands in register %7 (dest pointer) to all users of the return type of memcpy().
    // Thus, we only need state types as result types of the operation here.
    std::vector<std::shared_ptr<const rvsdg::Type>> types(1, IOStateType::Create());
    types.insert(types.end(), numMemoryStates, MemoryStateType::Create());
    return types;
  }
};
 
class MemSetOperation : public rvsdg::SimpleOperation
{
protected:
  MemSetOperation(
      const std::vector<std::shared_ptr<const rvsdg::Type>> & operandTypes,
      const std::vector<std::shared_ptr<const rvsdg::Type>> & resultTypes)
      : SimpleOperation(operandTypes, resultTypes)
  {
    JLM_ASSERT(operandTypes.size() >= 3);
 
    auto & dstAddressType = *operandTypes[0];
    JLM_ASSERT(is<PointerType>(dstAddressType));
 
    if (auto & valueType = *operandTypes[1]; valueType != *rvsdg::BitType::Create(8))
    {
      throw std::runtime_error("Expected 8 bit integer type.");
    }
 
    if (auto & lengthType = *operandTypes[2];
        lengthType != *rvsdg::BitType::Create(32) && lengthType != *rvsdg::BitType::Create(64))
    {
      throw util::Error("Expected 32 bit or 64 bit integer type.");
    }
  }
 
public:
  [[nodiscard]] const rvsdg::BitType &
  lengthType() const noexcept
  {
    const auto type = std::dynamic_pointer_cast<const rvsdg::BitType>(argument(2));
    JLM_ASSERT(type != nullptr);
    JLM_ASSERT(type->nbits() == 32 || type->nbits() == 64);
    return *type;
  }
 
  [[nodiscard]] virtual size_t
  numMemoryStates() const noexcept = 0;
 
  [[nodiscard]] static rvsdg::Input &
  destinationInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemSetOperation>(&node));
    const auto input = node.input(0);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  valueInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemSetOperation>(&node));
    const auto input = node.input(1);
    JLM_ASSERT(*input->Type() == *rvsdg::BitType::Create(8));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  lengthInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemSetOperation>(&node));
    const auto input = node.input(2);
    JLM_ASSERT(
        *input->Type() == *rvsdg::BitType::Create(32)
        || *input->Type() == *rvsdg::BitType::Create(64));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  mapMemoryStateOutputToInput(const rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [memsetNode, memsetOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemSetOperation>(output);
    JLM_ASSERT(memsetOperation);
    const auto numNonMemoryStateOutputs =
        memsetNode->noutputs() - memsetOperation->numMemoryStates();
    JLM_ASSERT(output.index() >= numNonMemoryStateOutputs);
    const auto numNonMemoryStateInputs = memsetNode->ninputs() - memsetOperation->numMemoryStates();
    const auto inputIndex = numNonMemoryStateInputs + (output.index() - numNonMemoryStateOutputs);
    const auto input = memsetNode->input(inputIndex);
    JLM_ASSERT(is<MemoryStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  mapMemoryStateInputToOutput(const rvsdg::Input & input)
  {
    JLM_ASSERT(is<MemoryStateType>(input.Type()));
    auto [memsetNode, memsetOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemSetOperation>(input);
    JLM_ASSERT(memsetOperation);
    const auto numNonMemoryStateInputs = memsetNode->ninputs() - memsetOperation->numMemoryStates();
    JLM_ASSERT(input.index() >= numNonMemoryStateInputs);
    const auto numNonMemoryStateOutputs =
        memsetNode->noutputs() - memsetOperation->numMemoryStates();
    const auto outputIndex = numNonMemoryStateOutputs + (input.index() - numNonMemoryStateInputs);
    const auto output = memsetNode->output(outputIndex);
    JLM_ASSERT(is<MemoryStateType>(output->Type()));
    return *output;
  }
 
  [[nodiscard]] static rvsdg::Node::OutputIteratorRange
  memoryStateOutputs(const rvsdg::Node & node) noexcept
  {
    const auto memSetOperation = util::assertedCast<const MemSetOperation>(&node.GetOperation());
    if (memSetOperation->numMemoryStates() == 0)
    {
      return { rvsdg::Output::Iterator(nullptr), rvsdg::Output::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.output(memSetOperation->nresults() - memSetOperation->numMemoryStates());
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Output::Iterator(firstMemoryStateOutput), rvsdg::Output::Iterator(nullptr) };
  }
};
 
class MemSetNonVolatileOperation final : public MemSetOperation
{
public:
  ~MemSetNonVolatileOperation() noexcept override;
 
  MemSetNonVolatileOperation(std::shared_ptr<const rvsdg::Type> lengthType, size_t numMemoryStates)
      : MemSetOperation(
            createOperandTypes(std::move(lengthType), numMemoryStates),
            createResultTypes(numMemoryStates))
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] size_t
  numMemoryStates() const noexcept override;
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(
      const Variable & destination,
      const Variable & value,
      const Variable & length,
      const std::vector<const Variable *> & memoryStates)
  {
    std::vector operands = { &destination, &value, &length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation =
        std::make_unique<MemSetNonVolatileOperation>(length.Type(), memoryStates.size());
    return ThreeAddressCode::create(std::move(operation), operands);
  }
 
  static rvsdg::SimpleNode &
  createNode(
      rvsdg::Output & destination,
      rvsdg::Output & value,
      rvsdg::Output & length,
      const std::vector<rvsdg::Output *> & memoryStates)
  {
    std::vector operands = { &destination, &value, &length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    return rvsdg::CreateOpNode<MemSetNonVolatileOperation>(
        operands,
        length.Type(),
        memoryStates.size());
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  createOperandTypes(
      const std::shared_ptr<const rvsdg::Type> & lengthType,
      const size_t numMemoryStates)
  {
    const auto pointerType = PointerType::Create();
    const auto & valueType = rvsdg::BitType::Create(8);
    std::vector<std::shared_ptr<const rvsdg::Type>> types = { pointerType, valueType, lengthType };
    types.insert(types.end(), numMemoryStates, MemoryStateType::Create());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  createResultTypes(size_t numMemoryStates)
  {
    // The memset() standard C library call has as return type void*, but LLVM models the
    // function call nevertheless as:
    // call void @llvm.memset.p0.i64(ptr %0, i8 0, i64 8, i1 false)
    //
    // LLVM simply hands in register %7 (dest pointer) to all users of the return type of memset().
    // Thus, we only need state types as result types of the operation here.
    return { numMemoryStates, MemoryStateType::Create() };
  }
};
 
class MemMoveOperation : public rvsdg::SimpleOperation
{
protected:
  MemMoveOperation(
      const std::vector<std::shared_ptr<const rvsdg::Type>> & operandTypes,
      const std::vector<std::shared_ptr<const rvsdg::Type>> & resultTypes)
      : SimpleOperation(operandTypes, resultTypes)
  {
    JLM_ASSERT(operandTypes.size() >= 3);
 
    auto & destAddressType = *operandTypes[0];
    JLM_ASSERT(is<PointerType>(destAddressType));
 
    auto & srcAddressType = *operandTypes[1];
    JLM_ASSERT(is<PointerType>(srcAddressType));
 
    auto & lengthType = *operandTypes[2];
    JLM_ASSERT(
        lengthType == *rvsdg::BitType::Create(32) || lengthType == *rvsdg::BitType::Create(64));
  }
 
public:
  [[nodiscard]] const rvsdg::BitType &
  lengthType() const noexcept
  {
    const auto type = std::dynamic_pointer_cast<const rvsdg::BitType>(argument(2));
    JLM_ASSERT(type != nullptr);
    JLM_ASSERT(type->nbits() == 32 || type->nbits() == 64);
    return *type;
  }
 
  [[nodiscard]] virtual size_t
  numMemoryStates() const noexcept = 0;
 
  [[nodiscard]] static rvsdg::Input &
  destinationInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemMoveOperation>(&node));
    const auto input = node.input(0);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  sourceInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemMoveOperation>(&node));
    const auto input = node.input(1);
    JLM_ASSERT(is<PointerType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  lengthInput(const rvsdg::Node & node) noexcept
  {
    JLM_ASSERT(is<MemMoveOperation>(&node));
    const auto input = node.input(2);
    const auto type = std::dynamic_pointer_cast<const rvsdg::BitType>(node.input(2)->Type());
    JLM_ASSERT(type != nullptr);
    JLM_ASSERT(type->nbits() == 32 || type->nbits() == 64);
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Input &
  mapMemoryStateOutputToInput(const rvsdg::Output & output)
  {
    JLM_ASSERT(is<MemoryStateType>(output.Type()));
    auto [memmoveNode, memmoveOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemMoveOperation>(output);
    JLM_ASSERT(memmoveOperation);
    const auto numNonMemoryStateOutputs =
        memmoveNode->noutputs() - memmoveOperation->numMemoryStates();
    JLM_ASSERT(output.index() >= numNonMemoryStateOutputs);
    const auto numNonMemoryStateInputs =
        memmoveNode->ninputs() - memmoveOperation->numMemoryStates();
    const auto inputIndex = numNonMemoryStateInputs + (output.index() - numNonMemoryStateOutputs);
    const auto input = memmoveNode->input(inputIndex);
    JLM_ASSERT(is<MemoryStateType>(input->Type()));
    return *input;
  }
 
  [[nodiscard]] static rvsdg::Output &
  mapMemoryStateInputToOutput(const rvsdg::Input & input)
  {
    JLM_ASSERT(is<MemoryStateType>(input.Type()));
    auto [memmoveNode, memmoveOperation] =
        rvsdg::TryGetSimpleNodeAndOptionalOp<MemMoveOperation>(input);
    JLM_ASSERT(memmoveOperation);
    const auto numNonMemoryStateInputs =
        memmoveNode->ninputs() - memmoveOperation->numMemoryStates();
    JLM_ASSERT(input.index() >= numNonMemoryStateInputs);
    const auto numNonMemoryStateOutputs =
        memmoveNode->noutputs() - memmoveOperation->numMemoryStates();
    const auto outputIndex = numNonMemoryStateOutputs + (input.index() - numNonMemoryStateInputs);
    const auto output = memmoveNode->output(outputIndex);
    JLM_ASSERT(is<MemoryStateType>(output->Type()));
    return *output;
  }
 
  [[nodiscard]] static rvsdg::Node::OutputIteratorRange
  memoryStateOutputs(const rvsdg::Node & node) noexcept
  {
    const auto memMoveOperation = util::assertedCast<const MemMoveOperation>(&node.GetOperation());
    if (memMoveOperation->numMemoryStates() == 0)
    {
      return { rvsdg::Output::Iterator(nullptr), rvsdg::Output::Iterator(nullptr) };
    }
 
    const auto firstMemoryStateOutput =
        node.output(memMoveOperation->nresults() - memMoveOperation->numMemoryStates());
    JLM_ASSERT(is<MemoryStateType>(firstMemoryStateOutput->Type()));
    return { rvsdg::Output::Iterator(firstMemoryStateOutput), rvsdg::Output::Iterator(nullptr) };
  }
};
 
class MemMoveNonVolatileOperation final : public MemMoveOperation
{
public:
  ~MemMoveNonVolatileOperation() noexcept override;
 
  MemMoveNonVolatileOperation(std::shared_ptr<const rvsdg::Type> lengthType, size_t numMemoryStates)
      : MemMoveOperation(
            checkAndCreateOperandTypes(std::move(lengthType), numMemoryStates),
            createResultTypes(numMemoryStates))
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] size_t
  numMemoryStates() const noexcept override;
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(
      const Variable & dest,
      const Variable & src,
      const Variable & length,
      const std::vector<const Variable *> & memoryStates)
  {
    std::vector operands = { &dest, &src, &length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    auto operation =
        std::make_unique<MemMoveNonVolatileOperation>(length.Type(), memoryStates.size());
    return ThreeAddressCode::create(std::move(operation), operands);
  }
 
  static rvsdg::SimpleNode &
  createNode(
      rvsdg::Output & dest,
      rvsdg::Output & src,
      rvsdg::Output & length,
      const std::vector<rvsdg::Output *> & memoryStates)
  {
    std::vector operands = { &dest, &src, &length };
    operands.insert(operands.end(), memoryStates.begin(), memoryStates.end());
 
    return rvsdg::CreateOpNode<MemMoveNonVolatileOperation>(
        operands,
        length.Type(),
        memoryStates.size());
  }
 
private:
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  checkAndCreateOperandTypes(
      const std::shared_ptr<const rvsdg::Type> & lengthType,
      const size_t numMemoryStates)
  {
    const auto bitType = std::dynamic_pointer_cast<const rvsdg::BitType>(lengthType);
    if (!bitType || (bitType->nbits() != 32 && bitType->nbits() != 64))
    {
      throw std::runtime_error("lengthType must be a 32-bit or 64-bit integer type");
    }
 
    std::vector<std::shared_ptr<const rvsdg::Type>> types = { PointerType::Create(),
                                                              PointerType::Create(),
                                                              lengthType };
    types.insert(types.end(), numMemoryStates, MemoryStateType::Create());
    return types;
  }
 
  static std::vector<std::shared_ptr<const rvsdg::Type>>
  createResultTypes(size_t numMemoryStates)
  {
    // The memmove() standard C library call has as return type void*, but LLVM models the
    // function call nevertheless as:
    // call void @llvm.memmove.p0.p0.i64(ptr %0, i8 0, i64 8, i1 false)
    //
    // LLVM simply hands in register %7 (dest pointer) to all users of the return type of memmove().
    // Thus, we only need state types as result types of the operation here.
    return { numMemoryStates, MemoryStateType::Create() };
  }
};
 
class UMaxOperation final : public rvsdg::SimpleOperation
{
public:
  ~UMaxOperation() noexcept override;
 
  explicit UMaxOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : SimpleOperation({ type, type }, { type })
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand1, const Variable & operand2)
  {
    auto operation = std::make_unique<UMaxOperation>(operand1.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand1, &operand2 });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<UMaxOperation>(
        {
            &operand1,
            &operand2,
        },
        operand1.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
class SMinOperation final : public rvsdg::SimpleOperation
{
public:
  ~SMinOperation() noexcept override;
 
  explicit SMinOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : SimpleOperation({ type, type }, { type })
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand1, const Variable & operand2)
  {
    auto operation = std::make_unique<SMinOperation>(operand1.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand1, &operand2 });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<SMinOperation>(
        {
            &operand1,
            &operand2,
        },
        operand1.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
class UMinOperation final : public rvsdg::SimpleOperation
{
public:
  ~UMinOperation() noexcept override;
 
  explicit UMinOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : SimpleOperation({ type, type }, { type })
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand1, const Variable & operand2)
  {
    auto operation = std::make_unique<UMinOperation>(operand1.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand1, &operand2 });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<UMinOperation>(
        {
            &operand1,
            &operand2,
        },
        operand1.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
class FAbsOperation final : public rvsdg::UnaryOperation
{
public:
  ~FAbsOperation() noexcept override;
 
  explicit FAbsOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : UnaryOperation(type, type)
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand)
  {
    auto operation = std::make_unique<FAbsOperation>(operand.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand)
  {
    return rvsdg::CreateOpNode<FAbsOperation>(
        {
            &operand,
        },
        operand.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
class AbsOperation final : public rvsdg::SimpleOperation
{
public:
  ~AbsOperation() noexcept override;
 
  explicit AbsOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : SimpleOperation({ type, rvsdg::BitType::Create(1) }, { type })
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand1, const Variable & operand2)
  {
    auto operation = std::make_unique<AbsOperation>(operand1.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand1, &operand2 });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<AbsOperation>(
        {
            &operand1,
            &operand2,
        },
        operand1.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
class SMaxOperation final : public rvsdg::SimpleOperation
{
public:
  ~SMaxOperation() noexcept override;
 
  explicit SMaxOperation(const std::shared_ptr<const rvsdg::Type> & type)
      : SimpleOperation({ type, type }, { type })
  {
    checkType(type);
  }
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] std::shared_ptr<const rvsdg::Type>
  getType() const noexcept
  {
    return result(0);
  }
 
  static std::unique_ptr<ThreeAddressCode>
  createTac(const Variable & operand1, const Variable & operand2)
  {
    auto operation = std::make_unique<SMaxOperation>(operand1.Type());
    return ThreeAddressCode::create(std::move(operation), { &operand1, &operand2 });
  }
 
  static rvsdg::SimpleNode &
  createNode(rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<SMaxOperation>(
        {
            &operand1,
            &operand2,
        },
        operand1.Type());
  }
 
private:
  static void
  checkType(const std::shared_ptr<const rvsdg::Type> & type);
};
 
}
 
#endif