simple-node.hpp

Go to the documentation of this file.

/*
 * Copyright 2016 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_SIMPLE_NODE_HPP
#define JLM_RVSDG_SIMPLE_NODE_HPP
 
#include <jlm/rvsdg/node.hpp>
 
#include <optional>
 
namespace jlm::rvsdg
{
 
class SimpleOperation;
 
class SimpleNode final : public Node
{
public:
  ~SimpleNode() override;
 
private:
  SimpleNode(
      rvsdg::Region & region,
      std::unique_ptr<SimpleOperation> operation,
      const std::vector<jlm::rvsdg::Output *> & operands);
 
public:
  NodeInput *
  input(size_t index) const noexcept;
 
  NodeOutput *
  output(size_t index) const noexcept;
 
  [[nodiscard]] const SimpleOperation &
  GetOperation() const noexcept override;
 
  Node *
  copy(Region * region, const std::vector<Output *> & operands) const override;
 
  Node *
  copy(Region * region, SubstitutionMap & smap) const override;
 
  std::string
  DebugString() const override;
 
  static SimpleNode &
  Create(
      Region & region,
      std::unique_ptr<Operation> operation,
      const std::vector<rvsdg::Output *> & operands)
  {
    if (!is<SimpleOperation>(*operation))
      throw util::Error("Expected operation derived from SimpleOperation");
 
    std::unique_ptr<SimpleOperation> simpleOperation(
        util::assertedCast<SimpleOperation>(operation.release()));
    return *new SimpleNode(region, std::move(simpleOperation), operands);
  }
 
private:
  std::unique_ptr<SimpleOperation> Operation_;
};
 
std::optional<std::vector<rvsdg::Output *>>
NormalizeSimpleOperationCommonNodeElimination(
    Region & region,
    const SimpleOperation & operation,
    const std::vector<rvsdg::Output *> & operands);
 
inline NodeInput *
SimpleNode::input(size_t index) const noexcept
{
  return Node::input(index);
}
 
inline NodeOutput *
SimpleNode::output(size_t index) const noexcept
{
  return Node::output(index);
}
 
template<typename OperatorType, typename... OperatorArguments>
SimpleNode &
CreateOpNode(const std::vector<Output *> & operands, OperatorArguments... operatorArguments)
{
  JLM_ASSERT(!operands.empty());
  return SimpleNode::Create(
      *operands[0]->region(),
      std::make_unique<OperatorType>(std::move(operatorArguments)...),
      operands);
}
 
template<typename OperatorType, typename... OperatorArguments>
SimpleNode &
CreateOpNode(Region & region, OperatorArguments... operatorArguments)
{
  return SimpleNode::Create(
      region,
      std::make_unique<OperatorType>(std::move(operatorArguments)...),
      {});
}
 
template<typename TOperation>
[[nodiscard]] std::pair<SimpleNode *, const TOperation *>
TryGetSimpleNodeAndOptionalOp(const Input & input) noexcept
{
  const auto simpleNode = TryGetOwnerNode<SimpleNode>(input);
  if (!simpleNode)
  {
    return std::make_pair(nullptr, nullptr);
  }
 
  if (auto operation = dynamic_cast<const TOperation *>(&simpleNode->GetOperation()))
  {
    return std::make_pair(simpleNode, operation);
  }
 
  return std::make_pair(simpleNode, nullptr);
}
 
template<typename TOperation>
[[nodiscard]] std::pair<SimpleNode *, const TOperation *>
TryGetSimpleNodeAndOptionalOp(const Output & output) noexcept
{
  const auto simpleNode = TryGetOwnerNode<SimpleNode>(output);
  if (!simpleNode)
  {
    return std::make_pair(nullptr, nullptr);
  }
 
  if (auto operation = dynamic_cast<const TOperation *>(&simpleNode->GetOperation()))
  {
    return std::make_pair(simpleNode, operation);
  }
 
  return std::make_pair(simpleNode, nullptr);
}
 
template<typename TOperation>
[[nodiscard]] std::pair<const SimpleNode *, const TOperation *>
TryGetSimpleNodeAndOptionalOp(const Node & node) noexcept
{
  const auto simpleNode = dynamic_cast<const SimpleNode *>(&node);
  if (!simpleNode)
  {
    return std::make_pair(nullptr, nullptr);
  }
  if (auto operation = dynamic_cast<const TOperation *>(&simpleNode->GetOperation()))
  {
    return std::make_pair(simpleNode, operation);
  }
  return std::make_pair(simpleNode, nullptr);
}
 
}
 
#endif