delta.hpp

Go to the documentation of this file.

/*
 * Copyright 2017 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_DELTA_HPP
#define JLM_RVSDG_DELTA_HPP
 
#include <jlm/rvsdg/region.hpp>
#include <jlm/rvsdg/structural-node.hpp>
 
namespace jlm::rvsdg
{
 
class DeltaOperation : public rvsdg::StructuralOperation
{
public:
  ~DeltaOperation() noexcept override;
 
  DeltaOperation(
      std::shared_ptr<const rvsdg::Type> type,
      bool constant,
      std::shared_ptr<const rvsdg::Type> reftype)
      : constant_(constant),
        type_(std::move(type)),
        reftype_(std::move(reftype))
  {}
 
  DeltaOperation(const DeltaOperation & other) = default;
 
  DeltaOperation(DeltaOperation && other) noexcept = default;
 
  DeltaOperation &
  operator=(const DeltaOperation &) = delete;
 
  DeltaOperation &
  operator=(DeltaOperation &&) = delete;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  [[nodiscard]] bool
  operator==(const Operation & other) const noexcept override;
 
  bool
  constant() const noexcept
  {
    return constant_;
  }
 
  [[nodiscard]] const rvsdg::Type &
  type() const noexcept
  {
    return *type_;
  }
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::Type> &
  Type() const noexcept
  {
    return type_;
  }
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::Type> &
  ReferenceType() const noexcept
  {
    return reftype_;
  }
 
  static inline std::unique_ptr<DeltaOperation>
  Create(
      std::shared_ptr<const rvsdg::Type> type,
      bool constant,
      std::shared_ptr<const rvsdg::Type> reftype)
  {
    return std::make_unique<DeltaOperation>(std::move(type), constant, std::move(reftype));
  }
 
private:
  bool constant_;
  std::shared_ptr<const rvsdg::Type> type_;
  std::shared_ptr<const rvsdg::Type> reftype_;
};
 
class DeltaNode final : public rvsdg::StructuralNode
{
public:
  ~DeltaNode() noexcept override;
 
private:
  DeltaNode(rvsdg::Region * parent, std::unique_ptr<DeltaOperation> op)
      : StructuralNode(parent, 1),
        Operation_(std::move(op))
  {}
 
public:
  struct ContextVar
  {
    rvsdg::Input * input;
 
    rvsdg::Output * inner;
  };
 
  ContextVar
  AddContextVar(jlm::rvsdg::Output & origin);
 
  [[nodiscard]] ContextVar
  MapInputContextVar(const rvsdg::Input & input) const noexcept;
 
  [[nodiscard]] ContextVar
  MapBinderContextVar(const rvsdg::Output & output) const noexcept;
 
  [[nodiscard]] std::vector<ContextVar>
  GetContextVars() const noexcept;
 
  rvsdg::Region *
  subregion() const noexcept
  {
    return StructuralNode::subregion(0);
  }
 
  [[nodiscard]] const DeltaOperation &
  GetOperation() const noexcept override;
 
  [[nodiscard]] const std::shared_ptr<const rvsdg::Type> &
  Type() const noexcept
  {
    return GetOperation().Type();
  }
 
  bool
  constant() const noexcept
  {
    return GetOperation().constant();
  }
 
  template<typename F>
  size_t
  RemoveDeltaInputsWhere(const F & match);
 
  size_t
  PruneDeltaInputs()
  {
    auto match = [](const rvsdg::Input &)
    {
      return true;
    };
 
    return RemoveDeltaInputsWhere(match);
  }
 
  [[nodiscard]] rvsdg::Output &
  output() const noexcept;
 
  [[nodiscard]] rvsdg::Input &
  result() const noexcept;
 
  DeltaNode *
  copy(rvsdg::Region * region, const std::vector<jlm::rvsdg::Output *> & operands) const override;
 
  DeltaNode *
  copy(rvsdg::Region * region, rvsdg::SubstitutionMap & smap) const override;
 
  static DeltaNode *
  Create(rvsdg::Region * parent, std::unique_ptr<DeltaOperation> op)
  {
    return new DeltaNode(parent, std::move(op));
  }
 
  rvsdg::Output &
  finalize(rvsdg::Output * result);
 
private:
  std::unique_ptr<DeltaOperation> Operation_;
};
 
template<typename F>
size_t
DeltaNode::RemoveDeltaInputsWhere(const F & match)
{
  util::HashSet<size_t> inputIndices;
  util::HashSet<size_t> argumentIndices;
  for (auto [input, argument] : GetContextVars())
  {
    if (argument->IsDead() && match(*input))
    {
      inputIndices.insert(input->index());
      argumentIndices.insert(argument->index());
    }
  }
 
  [[maybe_unused]] const auto numRemoveArguments = subregion()->RemoveArguments(argumentIndices);
  JLM_ASSERT(numRemoveArguments == argumentIndices.Size());
 
  [[maybe_unused]] const auto numRemovedInputs = RemoveInputs(inputIndices);
  JLM_ASSERT(numRemovedInputs == inputIndices.Size());
 
  return numRemovedInputs;
}
 
}
 
#endif