IntegerOperations.cpp

Go to the documentation of this file.

/*
 * Copyright 2025 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#include <jlm/llvm/ir/operators/IntegerOperations.hpp>
#include <jlm/llvm/ir/Trace.hpp>
 
namespace jlm::llvm
{
 
template<typename TBinOp>
static IntegerValueRepresentation
foldBinaryOperation(const IntegerValueRepresentation & r1, const IntegerValueRepresentation & r2)
{
  static_assert(std::is_base_of_v<IntegerBinaryOperation, TBinOp>);
 
  if constexpr (std::is_same_v<TBinOp, IntegerEqOperation>)
    return IntegerValueRepresentation(r1.eq(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerNeOperation>)
    return IntegerValueRepresentation(r1.ne(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSgeOperation>)
    return IntegerValueRepresentation(r1.sge(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSgtOperation>)
    return IntegerValueRepresentation(r1.sgt(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSleOperation>)
    return IntegerValueRepresentation(r1.sle(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSltOperation>)
    return IntegerValueRepresentation(r1.slt(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerUgeOperation>)
    return IntegerValueRepresentation(r1.uge(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerUgtOperation>)
    return IntegerValueRepresentation(r1.ugt(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerUleOperation>)
    return IntegerValueRepresentation(r1.ule(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerUltOperation>)
    return IntegerValueRepresentation(r1.ult(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerAddOperation>)
    return IntegerValueRepresentation(r1.add(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSubOperation>)
    return IntegerValueRepresentation(r1.sub(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerMulOperation>)
    return IntegerValueRepresentation(r1.mul(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSDivOperation>)
    return IntegerValueRepresentation(r1.sdiv(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerUDivOperation>)
    return IntegerValueRepresentation(r1.udiv(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerSRemOperation>)
    return IntegerValueRepresentation(r1.smod(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerURemOperation>)
    return IntegerValueRepresentation(r1.umod(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerAShrOperation>)
    return IntegerValueRepresentation(r1.ashr(r2.to_uint()));
  else if constexpr (std::is_same_v<TBinOp, IntegerShlOperation>)
    return IntegerValueRepresentation(r1.shl(r2.to_uint()));
  else if constexpr (std::is_same_v<TBinOp, IntegerLShrOperation>)
    return IntegerValueRepresentation(r1.shr(r2.to_uint()));
  else if constexpr (std::is_same_v<TBinOp, IntegerOrOperation>)
    return IntegerValueRepresentation(r1.lor(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerAndOperation>)
    return IntegerValueRepresentation(r1.land(r2));
  else if constexpr (std::is_same_v<TBinOp, IntegerXorOperation>)
    return IntegerValueRepresentation(r1.lxor(r2));
  else
    static_assert(sizeof(TBinOp) == 0, "Unsupported binary operation!");
}
 
template<typename TBinOp>
static std::optional<std::vector<rvsdg::Output *>>
foldBinaryOperationConstants(const std::vector<rvsdg::Output *> & operands)
{
  static_assert(std::is_base_of_v<IntegerBinaryOperation, TBinOp>);
 
  JLM_ASSERT(operands.size() == 2);
  auto & operand1 = *operands[0];
  auto & operand2 = *operands[1];
 
  const auto & tracedOperand1 = llvm::traceOutput(operand1, false);
  auto [c1Node, c1Operation] =
      rvsdg::TryGetSimpleNodeAndOptionalOp<IntegerConstantOperation>(tracedOperand1);
  if (!c1Operation)
    return std::nullopt;
 
  const auto & tracedOperand2 = llvm::traceOutput(operand2, false);
  auto [c2Node, c2Operation] =
      rvsdg::TryGetSimpleNodeAndOptionalOp<IntegerConstantOperation>(tracedOperand2);
  if (!c2Operation)
    return std::nullopt;
 
  auto & c1Representation = c1Operation->Representation();
  auto & c2Representation = c2Operation->Representation();
  const auto & resultRepresentation =
      foldBinaryOperation<TBinOp>(c1Representation, c2Representation);
 
  auto result =
      IntegerConstantOperation::Create(*operand1.region(), resultRepresentation).output(0);
 
  return std::vector<rvsdg::Output *>({ result });
}
 
static std::optional<std::vector<rvsdg::Output *>>
normalizeIdenticalOperands(const std::vector<rvsdg::Output *> & operands, const std::int64_t result)
{
  JLM_ASSERT(result == 0 || result == 1);
  JLM_ASSERT(operands.size() == 2);
  auto & operand1 = *operands[0];
  auto & operand2 = *operands[1];
 
  const auto & tracedOperand1 = llvm::traceOutput(operand1, true);
  const auto & tracedOperand2 = llvm::traceOutput(operand2, true);
  if (&tracedOperand1 == &tracedOperand2)
  {
    return outputs(&IntegerConstantOperation::Create(*operand1.region(), 1, result));
  }
 
  return std::nullopt;
}
 
IntegerConstantOperation::~IntegerConstantOperation() = default;
 
std::unique_ptr<rvsdg::Operation>
IntegerConstantOperation::copy() const
{
  return std::make_unique<IntegerConstantOperation>(*this);
}
 
std::string
IntegerConstantOperation::debug_string() const
{
  if (Representation().is_known() && Representation().nbits() <= 64)
    return util::strfmt("I", Representation().nbits(), "(", Representation().to_uint(), ")");
 
  return Representation().str();
}
 
bool
IntegerConstantOperation::operator==(const Operation & other) const noexcept
{
  const auto constant = dynamic_cast<const IntegerConstantOperation *>(&other);
  return constant && constant->Representation() == Representation();
}
 
IntegerBinaryOperation::~IntegerBinaryOperation() noexcept = default;
 
IntegerAddOperation::~IntegerAddOperation() noexcept = default;
 
bool
IntegerAddOperation::operator==(const Operation & other) const noexcept
{
  const auto addOperation = dynamic_cast<const IntegerAddOperation *>(&other);
  return addOperation && addOperation->Type() == Type();
}
 
std::string
IntegerAddOperation::debug_string() const
{
  return "IAdd";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerAddOperation::copy() const
{
  return std::make_unique<IntegerAddOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerAddOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerAddOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerAddOperation::flags() const noexcept
{
  return flags::associative | flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerAddOperation::foldConstants(
    const IntegerAddOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerAddOperation>(operands);
}
 
IntegerSubOperation::~IntegerSubOperation() noexcept = default;
 
bool
IntegerSubOperation::operator==(const Operation & other) const noexcept
{
  const auto subOperation = dynamic_cast<const IntegerSubOperation *>(&other);
  return subOperation && subOperation->Type() == Type();
}
 
std::string
IntegerSubOperation::debug_string() const
{
  return "ISub";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSubOperation::copy() const
{
  return std::make_unique<IntegerSubOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSubOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSubOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSubOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSubOperation::normalizeAdditiveInverse(
    const IntegerSubOperation & operation,
    const std::vector<rvsdg::Output *> & operands)
{
  JLM_ASSERT(operands.size() == 2);
  const auto & operand1 = *operands[0];
  const auto & operand2 = *operands[1];
 
  auto & tracedOperand1 = llvm::traceOutput(operand1, false);
  auto & tracedOperand2 = llvm::traceOutput(operand2, false);
 
  if (&tracedOperand1 != &tracedOperand2)
    return std::nullopt;
 
  return rvsdg::outputs(
      &IntegerConstantOperation::Create(*operand1.region(), operation.Type().nbits(), 0));
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSubOperation::foldConstants(
    const IntegerSubOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSubOperation>(operands);
}
 
IntegerMulOperation::~IntegerMulOperation() noexcept = default;
 
bool
IntegerMulOperation::operator==(const Operation & other) const noexcept
{
  const auto mulOperation = dynamic_cast<const IntegerMulOperation *>(&other);
  return mulOperation && mulOperation->Type() == Type();
}
 
std::string
IntegerMulOperation::debug_string() const
{
  return "IMul";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerMulOperation::copy() const
{
  return std::make_unique<IntegerMulOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerMulOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerMulOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerMulOperation::flags() const noexcept
{
  return flags::associative | flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerMulOperation::foldConstants(
    const IntegerMulOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerMulOperation>(operands);
}
 
IntegerSDivOperation::~IntegerSDivOperation() noexcept = default;
 
bool
IntegerSDivOperation::operator==(const Operation & other) const noexcept
{
  const auto sdivOperation = dynamic_cast<const IntegerSDivOperation *>(&other);
  return sdivOperation && sdivOperation->Type() == Type();
}
 
std::string
IntegerSDivOperation::debug_string() const
{
  return "ISDiv";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSDivOperation::copy() const
{
  return std::make_unique<IntegerSDivOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSDivOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSDivOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSDivOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSDivOperation::foldConstants(
    const IntegerSDivOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSDivOperation>(operands);
}
 
IntegerUDivOperation::~IntegerUDivOperation() noexcept = default;
 
bool
IntegerUDivOperation::operator==(const Operation & other) const noexcept
{
  const auto udivOperation = dynamic_cast<const IntegerUDivOperation *>(&other);
  return udivOperation && udivOperation->Type() == Type();
}
 
std::string
IntegerUDivOperation::debug_string() const
{
  return "IUDiv";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerUDivOperation::copy() const
{
  return std::make_unique<IntegerUDivOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerUDivOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerUDivOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerUDivOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUDivOperation::foldConstants(
    const IntegerUDivOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerUDivOperation>(operands);
}
 
IntegerSRemOperation::~IntegerSRemOperation() noexcept = default;
 
bool
IntegerSRemOperation::operator==(const Operation & other) const noexcept
{
  const auto smodOperation = dynamic_cast<const IntegerSRemOperation *>(&other);
  return smodOperation && smodOperation->Type() == Type();
}
 
std::string
IntegerSRemOperation::debug_string() const
{
  return "ISMod";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSRemOperation::copy() const
{
  return std::make_unique<IntegerSRemOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSRemOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSRemOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSRemOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSRemOperation::foldConstants(
    const IntegerSRemOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSRemOperation>(operands);
}
 
IntegerURemOperation::~IntegerURemOperation() noexcept = default;
 
bool
IntegerURemOperation::operator==(const Operation & other) const noexcept
{
  const auto umodOperation = dynamic_cast<const IntegerURemOperation *>(&other);
  return umodOperation && umodOperation->Type() == Type();
}
 
std::string
IntegerURemOperation::debug_string() const
{
  return "IUMod";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerURemOperation::copy() const
{
  return std::make_unique<IntegerURemOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerURemOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerURemOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerURemOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerURemOperation::foldConstants(
    const IntegerURemOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerURemOperation>(operands);
}
 
IntegerAShrOperation::~IntegerAShrOperation() noexcept = default;
 
bool
IntegerAShrOperation::operator==(const Operation & other) const noexcept
{
  const auto ashrOperation = dynamic_cast<const IntegerAShrOperation *>(&other);
  return ashrOperation && ashrOperation->Type() == Type();
}
 
std::string
IntegerAShrOperation::debug_string() const
{
  return "IAShr";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerAShrOperation::copy() const
{
  return std::make_unique<IntegerAShrOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerAShrOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerAShrOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerAShrOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerAShrOperation::foldConstants(
    const IntegerAShrOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerAShrOperation>(operands);
}
 
IntegerShlOperation::~IntegerShlOperation() noexcept = default;
 
bool
IntegerShlOperation::operator==(const Operation & other) const noexcept
{
  const auto shlOperation = dynamic_cast<const IntegerShlOperation *>(&other);
  return shlOperation && shlOperation->Type() == Type();
}
 
std::string
IntegerShlOperation::debug_string() const
{
  return "IShl";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerShlOperation::copy() const
{
  return std::make_unique<IntegerShlOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerShlOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerShlOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerShlOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerShlOperation::foldConstants(
    const IntegerShlOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerShlOperation>(operands);
}
 
IntegerLShrOperation::~IntegerLShrOperation() noexcept = default;
 
bool
IntegerLShrOperation::operator==(const Operation & other) const noexcept
{
  const auto shrOperation = dynamic_cast<const IntegerLShrOperation *>(&other);
  return shrOperation && shrOperation->Type() == Type();
}
 
std::string
IntegerLShrOperation::debug_string() const
{
  return "IShr";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerLShrOperation::copy() const
{
  return std::make_unique<IntegerLShrOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerLShrOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerLShrOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerLShrOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerLShrOperation::foldConstants(
    const IntegerLShrOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerLShrOperation>(operands);
}
 
IntegerAndOperation::~IntegerAndOperation() noexcept = default;
 
bool
IntegerAndOperation::operator==(const Operation & other) const noexcept
{
  const auto andOperation = dynamic_cast<const IntegerAndOperation *>(&other);
  return andOperation && andOperation->Type() == Type();
}
 
std::string
IntegerAndOperation::debug_string() const
{
  return "IAnd";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerAndOperation::copy() const
{
  return std::make_unique<IntegerAndOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerAndOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerAndOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerAndOperation::flags() const noexcept
{
  return flags::associative | flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerAndOperation::foldConstants(
    const IntegerAndOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerAndOperation>(operands);
}
 
IntegerOrOperation::~IntegerOrOperation() noexcept = default;
 
bool
IntegerOrOperation::operator==(const Operation & other) const noexcept
{
  const auto orOperation = dynamic_cast<const IntegerOrOperation *>(&other);
  return orOperation && orOperation->Type() == Type();
}
 
std::string
IntegerOrOperation::debug_string() const
{
  return "IOr";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerOrOperation::copy() const
{
  return std::make_unique<IntegerOrOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerOrOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerOrOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerOrOperation::flags() const noexcept
{
  return flags::associative | flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerOrOperation::foldConstants(
    const IntegerOrOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerOrOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerOrOperation::normalizeIdempotent(
    const IntegerOrOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  JLM_ASSERT(operands.size() == 2);
  auto & operand1 = *operands[0];
  auto & operand2 = *operands[1];
 
  const auto & tracedOperand1 = llvm::traceOutput(operand1, true);
  auto [c1Node, c1Operation] =
      rvsdg::TryGetSimpleNodeAndOptionalOp<IntegerConstantOperation>(tracedOperand1);
  if (c1Operation && c1Operation->Representation().isZero())
  {
    return std::vector({ &operand2 });
  }
 
  const auto & tracedOperand2 = llvm::traceOutput(operand2, true);
  auto [c2Node, c2Operation] =
      rvsdg::TryGetSimpleNodeAndOptionalOp<IntegerConstantOperation>(tracedOperand2);
  if (c2Operation && c2Operation->Representation().isZero())
  {
    return std::vector({ &operand1 });
  }
 
  return std::nullopt;
}
 
IntegerXorOperation::~IntegerXorOperation() noexcept = default;
 
bool
IntegerXorOperation::operator==(const Operation & other) const noexcept
{
  const auto xorOperation = dynamic_cast<const IntegerXorOperation *>(&other);
  return xorOperation && xorOperation->Type() == Type();
}
 
std::string
IntegerXorOperation::debug_string() const
{
  return "IXor";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerXorOperation::copy() const
{
  return std::make_unique<IntegerXorOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerXorOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerXorOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerXorOperation::flags() const noexcept
{
  return flags::associative | flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerXorOperation::foldConstants(
    const IntegerXorOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerXorOperation>(operands);
}
 
IntegerEqOperation::~IntegerEqOperation() noexcept = default;
 
bool
IntegerEqOperation::operator==(const Operation & other) const noexcept
{
  const auto eqOperation = dynamic_cast<const IntegerEqOperation *>(&other);
  return eqOperation && eqOperation->result(0) == result(0);
}
 
std::string
IntegerEqOperation::debug_string() const
{
  return "IEq";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerEqOperation::copy() const
{
  return std::make_unique<IntegerEqOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerEqOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerEqOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerEqOperation::flags() const noexcept
{
  return flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerEqOperation::foldConstants(
    const IntegerEqOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerEqOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerEqOperation::normalizeIdenticalOperands(
    const IntegerEqOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 1);
}
 
IntegerNeOperation::~IntegerNeOperation() noexcept = default;
 
bool
IntegerNeOperation::operator==(const Operation & other) const noexcept
{
  const auto neOperation = dynamic_cast<const IntegerNeOperation *>(&other);
  return neOperation && neOperation->result(0) == result(0);
}
 
std::string
IntegerNeOperation::debug_string() const
{
  return "INe";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerNeOperation::copy() const
{
  return std::make_unique<IntegerNeOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerNeOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerNeOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerNeOperation::flags() const noexcept
{
  return flags::commutative;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerNeOperation::foldConstants(
    const IntegerNeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerNeOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerNeOperation::normalizeIdenticalOperands(
    const IntegerNeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 0);
}
 
IntegerSgeOperation::~IntegerSgeOperation() noexcept = default;
 
bool
IntegerSgeOperation::operator==(const Operation & other) const noexcept
{
  const auto sgeOperation = dynamic_cast<const IntegerSgeOperation *>(&other);
  return sgeOperation && sgeOperation->result(0) == result(0);
}
 
std::string
IntegerSgeOperation::debug_string() const
{
  return "ISge";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSgeOperation::copy() const
{
  return std::make_unique<IntegerSgeOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSgeOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSgeOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSgeOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSgeOperation::foldConstants(
    const IntegerSgeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSgeOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSgeOperation::normalizeIdenticalOperands(
    const IntegerSgeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 1);
}
 
IntegerSgtOperation::~IntegerSgtOperation() noexcept = default;
 
bool
IntegerSgtOperation::operator==(const Operation & other) const noexcept
{
  const auto sgtOperation = dynamic_cast<const IntegerSgtOperation *>(&other);
  return sgtOperation && sgtOperation->result(0) == result(0);
}
 
std::string
IntegerSgtOperation::debug_string() const
{
  return "ISgt";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSgtOperation::copy() const
{
  return std::make_unique<IntegerSgtOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSgtOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSgtOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSgtOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSgtOperation::foldConstants(
    const IntegerSgtOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSgtOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSgtOperation::normalizeIdenticalOperands(
    const IntegerSgtOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 0);
}
 
IntegerSleOperation::~IntegerSleOperation() noexcept = default;
 
bool
IntegerSleOperation::operator==(const Operation & other) const noexcept
{
  const auto sleOperation = dynamic_cast<const IntegerSleOperation *>(&other);
  return sleOperation && sleOperation->result(0) == result(0);
}
 
std::string
IntegerSleOperation::debug_string() const
{
  return "ISle";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSleOperation::copy() const
{
  return std::make_unique<IntegerSleOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSleOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSleOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSleOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSleOperation::foldConstants(
    const IntegerSleOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSleOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSleOperation::normalizeIdenticalOperands(
    const IntegerSleOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 1);
}
 
IntegerSltOperation::~IntegerSltOperation() noexcept = default;
 
bool
IntegerSltOperation::operator==(const Operation & other) const noexcept
{
  const auto sltOperation = dynamic_cast<const IntegerSltOperation *>(&other);
  return sltOperation && sltOperation->result(0) == result(0);
}
 
std::string
IntegerSltOperation::debug_string() const
{
  return "ISlt";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerSltOperation::copy() const
{
  return std::make_unique<IntegerSltOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerSltOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerSltOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerSltOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSltOperation::foldConstants(
    const IntegerSltOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerSltOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerSltOperation::normalizeIdenticalOperands(
    const IntegerSltOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 0);
}
 
IntegerUgeOperation::~IntegerUgeOperation() noexcept = default;
 
bool
IntegerUgeOperation::operator==(const Operation & other) const noexcept
{
  const auto ugeOperation = dynamic_cast<const IntegerUgeOperation *>(&other);
  return ugeOperation && ugeOperation->result(0) == result(0);
}
 
std::string
IntegerUgeOperation::debug_string() const
{
  return "IUge";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerUgeOperation::copy() const
{
  return std::make_unique<IntegerUgeOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerUgeOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerUgeOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerUgeOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUgeOperation::foldConstants(
    const IntegerUgeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerUgeOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUgeOperation::normalizeIdenticalOperands(
    const IntegerUgeOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 1);
}
 
IntegerUgtOperation::~IntegerUgtOperation() noexcept = default;
 
bool
IntegerUgtOperation::operator==(const Operation & other) const noexcept
{
  const auto ugtOperation = dynamic_cast<const IntegerUgtOperation *>(&other);
  return ugtOperation && ugtOperation->result(0) == result(0);
}
 
std::string
IntegerUgtOperation::debug_string() const
{
  return "IUgt";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerUgtOperation::copy() const
{
  return std::make_unique<IntegerUgtOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerUgtOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerUgtOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerUgtOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUgtOperation::foldConstants(
    const IntegerUgtOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerUgtOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUgtOperation::normalizeIdenticalOperands(
    const IntegerUgtOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 0);
}
 
IntegerUleOperation::~IntegerUleOperation() noexcept = default;
 
bool
IntegerUleOperation::operator==(const Operation & other) const noexcept
{
  const auto uleOperation = dynamic_cast<const IntegerUleOperation *>(&other);
  return uleOperation && uleOperation->result(0) == result(0);
}
 
std::string
IntegerUleOperation::debug_string() const
{
  return "IUle";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerUleOperation::copy() const
{
  return std::make_unique<IntegerUleOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerUleOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerUleOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerUleOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUleOperation::foldConstants(
    const IntegerUleOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerUleOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUleOperation::normalizeIdenticalOperands(
    const IntegerUleOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 1);
}
 
IntegerUltOperation::~IntegerUltOperation() noexcept = default;
 
bool
IntegerUltOperation::operator==(const Operation & other) const noexcept
{
  const auto ultOperation = dynamic_cast<const IntegerUltOperation *>(&other);
  return ultOperation && ultOperation->result(0) == result(0);
}
 
std::string
IntegerUltOperation::debug_string() const
{
  return "IUlt";
}
 
std::unique_ptr<rvsdg::Operation>
IntegerUltOperation::copy() const
{
  return std::make_unique<IntegerUltOperation>(*this);
}
 
rvsdg::binop_reduction_path_t
IntegerUltOperation::can_reduce_operand_pair(const rvsdg::Output *, const rvsdg::Output *)
    const noexcept
{
  return rvsdg::binop_reduction_none;
}
 
rvsdg::Output *
IntegerUltOperation::reduce_operand_pair(
    rvsdg::binop_reduction_path_t,
    rvsdg::Output *,
    rvsdg::Output *) const
{
  return nullptr;
}
 
enum rvsdg::BinaryOperation::flags
IntegerUltOperation::flags() const noexcept
{
  return flags::none;
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUltOperation::foldConstants(
    const IntegerUltOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return foldBinaryOperationConstants<IntegerUltOperation>(operands);
}
 
std::optional<std::vector<rvsdg::Output *>>
IntegerUltOperation::normalizeIdenticalOperands(
    const IntegerUltOperation &,
    const std::vector<rvsdg::Output *> & operands)
{
  return llvm::normalizeIdenticalOperands(operands, 0);
}
 
}