IntegerOperations.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_IR_OPERATORS_INTEGEROPERATIONS_HPP
#define JLM_LLVM_IR_OPERATORS_INTEGEROPERATIONS_HPP
 
#include <jlm/rvsdg/binary.hpp>
#include <jlm/rvsdg/bitstring/type.hpp>
#include <jlm/rvsdg/bitstring/value-representation.hpp>
#include <jlm/rvsdg/nullary.hpp>
 
namespace jlm::llvm
{
 
// FIXME: Implement our own value representation instead of re-using the bitstring value
// representation
using IntegerValueRepresentation = rvsdg::BitValueRepresentation;
 
class IntegerConstantOperation final : public rvsdg::NullaryOperation
{
public:
  ~IntegerConstantOperation() override;
 
  explicit IntegerConstantOperation(IntegerValueRepresentation representation)
      : NullaryOperation(rvsdg::BitType::Create(representation.nbits())),
        Representation_(std::move(representation))
  {}
 
  std::unique_ptr<Operation>
  copy() const override;
 
  std::string
  debug_string() const override;
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] const IntegerValueRepresentation &
  Representation() const noexcept
  {
    return Representation_;
  }
 
  static rvsdg::Node &
  Create(rvsdg::Region & region, IntegerValueRepresentation representation)
  {
    return rvsdg::CreateOpNode<IntegerConstantOperation>(region, std::move(representation));
  }
 
  static rvsdg::Node &
  Create(rvsdg::Region & region, std::size_t numBits, std::int64_t value)
  {
    return Create(region, { numBits, value });
  }
 
private:
  IntegerValueRepresentation Representation_;
};
 
class IntegerBinaryOperation : public rvsdg::BinaryOperation
{
public:
  ~IntegerBinaryOperation() noexcept override;
 
  IntegerBinaryOperation(
      const std::size_t numArgumentBits,
      const std::size_t numResultBits) noexcept
      : BinaryOperation(
            { rvsdg::BitType::Create(numArgumentBits), rvsdg::BitType::Create(numArgumentBits) },
            rvsdg::BitType::Create(numResultBits))
  {}
 
  [[nodiscard]] const rvsdg::BitType &
  Type() const noexcept
  {
    return *util::assertedCast<const rvsdg::BitType>(argument(0).get());
  }
};
 
class IntegerAddOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerAddOperation() noexcept override;
 
  explicit IntegerAddOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerAddOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerAddOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSubOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSubOperation() noexcept override;
 
  explicit IntegerSubOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSubOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeAdditiveInverse(
      const IntegerSubOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSubOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerMulOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerMulOperation() noexcept override;
 
  explicit IntegerMulOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerMulOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerMulOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSDivOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSDivOperation() noexcept override;
 
  explicit IntegerSDivOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSDivOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSDivOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerUDivOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerUDivOperation() noexcept override;
 
  explicit IntegerUDivOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerUDivOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerUDivOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSRemOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSRemOperation() noexcept override;
 
  explicit IntegerSRemOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSRemOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSRemOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerURemOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerURemOperation() noexcept override;
 
  explicit IntegerURemOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerURemOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerURemOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerAShrOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerAShrOperation() noexcept override;
 
  explicit IntegerAShrOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerAShrOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerAShrOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerShlOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerShlOperation() noexcept override;
 
  explicit IntegerShlOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerShlOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerShlOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerLShrOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerLShrOperation() noexcept override;
 
  explicit IntegerLShrOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerLShrOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerLShrOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerAndOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerAndOperation() noexcept override;
 
  explicit IntegerAndOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerAndOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerAndOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerOrOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerOrOperation() noexcept override;
 
  explicit IntegerOrOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerOrOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerOrOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdempotent(
      const IntegerOrOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerXorOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerXorOperation() noexcept override;
 
  explicit IntegerXorOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, numBits)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerXorOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerXorOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerEqOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerEqOperation() noexcept override;
 
  explicit IntegerEqOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerEqOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerEqOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerEqOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerNeOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerNeOperation() noexcept override;
 
  explicit IntegerNeOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerNeOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerNeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerNeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSgeOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSgeOperation() noexcept override;
 
  explicit IntegerSgeOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSgeOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSgeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerSgeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSgtOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSgtOperation() noexcept override;
 
  explicit IntegerSgtOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSgtOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSgtOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerSgtOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSleOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSleOperation() noexcept override;
 
  explicit IntegerSleOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSleOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSleOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerSleOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerSltOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerSltOperation() noexcept override;
 
  explicit IntegerSltOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerSltOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerSltOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerSltOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerUgeOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerUgeOperation() noexcept override;
 
  explicit IntegerUgeOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerUgeOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerUgeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerUgeOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerUgtOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerUgtOperation() noexcept override;
 
  explicit IntegerUgtOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerUgtOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerUgtOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerUgtOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerUleOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerUleOperation() noexcept override;
 
  explicit IntegerUleOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerUleOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerUleOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerUleOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
class IntegerUltOperation final : public IntegerBinaryOperation
{
public:
  ~IntegerUltOperation() noexcept override;
 
  explicit IntegerUltOperation(const std::size_t numBits)
      : IntegerBinaryOperation(numBits, 1)
  {}
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  rvsdg::binop_reduction_path_t
  can_reduce_operand_pair(const rvsdg::Output * op1, const rvsdg::Output * op2)
      const noexcept override;
 
  rvsdg::Output *
  reduce_operand_pair(rvsdg::binop_reduction_path_t path, rvsdg::Output * op1, rvsdg::Output * op2)
      const override;
 
  enum flags
  flags() const noexcept override;
 
  static rvsdg::Node &
  createNode(const size_t numBits, rvsdg::Output & operand1, rvsdg::Output & operand2)
  {
    return rvsdg::CreateOpNode<IntegerUltOperation>({ &operand1, &operand2 }, numBits);
  }
 
  static std::optional<std::vector<rvsdg::Output *>>
  foldConstants(
      const IntegerUltOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
 
  static std::optional<std::vector<rvsdg::Output *>>
  normalizeIdenticalOperands(
      const IntegerUltOperation & operation,
      const std::vector<rvsdg::Output *> & operands);
};
 
}
 
#endif // JLM_LLVM_IR_OPERATORS_INTEGEROPERATIONS_HPP