theta.hpp

Go to the documentation of this file.

/*
 * Copyright 2012 2013 2014 Helge Bahmann <hcb@chaoticmind.net>
 * Copyright 2013 2014 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_THETA_HPP
#define JLM_RVSDG_THETA_HPP
 
#include <jlm/rvsdg/control.hpp>
#include <jlm/rvsdg/region.hpp>
#include <jlm/rvsdg/structural-node.hpp>
#include <jlm/util/HashSet.hpp>
 
#include <optional>
 
namespace jlm::rvsdg
{
 
class ThetaOperation final : public StructuralOperation
{
public:
  ~ThetaOperation() noexcept override;
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
};
 
class ThetaNode final : public StructuralNode
{
public:
  ~ThetaNode() noexcept override;
 
private:
  explicit ThetaNode(rvsdg::Region & parent);
 
public:
  struct LoopVar
  {
    rvsdg::Input * input;
    rvsdg::Output * pre;
    rvsdg::Input * post;
    rvsdg::Output * output;
  };
 
  struct PredicateVar
  {
    rvsdg::Input * predicate;
  };
 
  [[nodiscard]] const ThetaOperation &
  GetOperation() const noexcept override;
 
  static ThetaNode *
  create(rvsdg::Region * parent)
  {
    return new ThetaNode(*parent);
  }
 
  [[nodiscard]] rvsdg::Region *
  subregion() const noexcept
  {
    return StructuralNode::subregion(0);
  }
 
  [[nodiscard]] RegionResult *
  predicate() const noexcept
  {
    auto result = subregion()->result(0);
    JLM_ASSERT(is<const ControlType>(result->Type()));
    return result;
  }
 
  inline void
  set_predicate(jlm::rvsdg::Output * p)
  {
    auto node = TryGetOwnerNode<Node>(*predicate()->origin());
 
    predicate()->divert_to(p);
    if (node && node->IsDead())
      remove(node);
  }
 
  LoopVar
  AddLoopVar(rvsdg::Output * origin);
 
  void
  RemoveLoopVars(std::vector<LoopVar> loopVars);
 
  ThetaNode *
  copy(rvsdg::Region * region, rvsdg::SubstitutionMap & smap) const override;
 
  [[nodiscard]] LoopVar
  MapInputLoopVar(const rvsdg::Input & input) const;
 
  [[nodiscard]] LoopVar
  MapPreLoopVar(const rvsdg::Output & argument) const;
 
  [[nodiscard]] LoopVar
  MapPostLoopVar(const rvsdg::Input & result) const;
 
  [[nodiscard]] std::variant<LoopVar, PredicateVar>
  mapResult(const rvsdg::Input & result) const;
 
  [[nodiscard]] LoopVar
  MapOutputLoopVar(const rvsdg::Output & output) const;
 
  [[nodiscard]] std::vector<LoopVar>
  GetLoopVars() const;
 
  static bool
  reduceStaticallyKnownPredicate(Node & node);
};
 
static inline bool
ThetaLoopVarIsInvariant(const ThetaNode::LoopVar & loopVar) noexcept
{
  return loopVar.post->origin() == loopVar.pre;
}
 
}
 
#endif