gamma.hpp

Go to the documentation of this file.

/*
 * Copyright 2010 2011 2012 2013 2014 Helge Bahmann <hcb@chaoticmind.net>
 * Copyright 2013 2014 2016 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_GAMMA_HPP
#define JLM_RVSDG_GAMMA_HPP
 
#include <optional>
 
#include <jlm/rvsdg/control.hpp>
#include <jlm/rvsdg/structural-node.hpp>
 
namespace jlm::rvsdg
{
 
class Output;
class Type;
 
class GammaOperation : public StructuralOperation
{
public:
  ~GammaOperation() noexcept override;
 
  explicit GammaOperation(size_t numAlternatives) noexcept
      : GammaOperation(numAlternatives, {})
  {}
 
  GammaOperation(
      size_t numAlternatives,
      std::vector<std::shared_ptr<const Type>> matchContentTypes) noexcept
      : StructuralOperation(),
        numAlternatives_(numAlternatives),
        MatchContentTypes_(std::move(matchContentTypes))
  {}
 
  inline size_t
  nalternatives() const noexcept
  {
    return numAlternatives_;
  }
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::shared_ptr<const Type>
  GetMatchContentType(std::size_t alternative) const;
 
private:
  size_t numAlternatives_;
  std::vector<std::shared_ptr<const Type>> MatchContentTypes_;
};
 
class GammaNode : public StructuralNode
{
public:
  ~GammaNode() noexcept override;
 
private:
  GammaNode(rvsdg::Output & predicate, std::unique_ptr<GammaOperation> op);
 
  GammaNode(
      rvsdg::Output & predicate,
      size_t nalternatives,
      std::vector<std::shared_ptr<const Type>> match_content_types);
 
public:
  struct MatchVar
  {
    rvsdg::Input * input;
    std::vector<rvsdg::Output *> matchContent;
  };
 
  struct EntryVar
  {
    rvsdg::Input * input;
    std::vector<rvsdg::Output *> branchArgument;
  };
 
  struct ExitVar
  {
    std::vector<rvsdg::Input *> branchResult;
    rvsdg::Output * output;
  };
 
  [[nodiscard]] const GammaOperation &
  GetOperation() const noexcept override;
 
  static GammaNode *
  create(jlm::rvsdg::Output * predicate, size_t nalternatives)
  {
    return new GammaNode(*predicate, nalternatives, {});
  }
 
  static GammaNode &
  Create(
      jlm::rvsdg::Output & predicate,
      size_t numAlternatives,
      std::vector<std::shared_ptr<const Type>> matchContentTypes)
  {
    return *new GammaNode(predicate, numAlternatives, std::move(matchContentTypes));
  }
 
  static GammaNode &
  Create(jlm::rvsdg::Output & predicate, std::unique_ptr<GammaOperation> op)
  {
    return *new GammaNode(predicate, std::move(op));
  }
 
  inline rvsdg::Input *
  predicate() const noexcept;
 
  EntryVar
  AddEntryVar(rvsdg::Output * origin);
 
  MatchVar
  GetMatchVar() const;
 
  std::vector<EntryVar>
  GetEntryVars() const;
 
  std::variant<MatchVar, EntryVar>
  MapInput(const rvsdg::Input & input) const;
 
  std::variant<MatchVar, EntryVar>
  MapBranchArgument(const rvsdg::Output & output) const;
 
  const rvsdg::Input &
  mapBranchArgumentToInput(const rvsdg::Output & output) const;
 
  Input &
  mapBranchArgumentToInput(Output & output) const;
 
  ExitVar
  AddExitVar(const std::vector<rvsdg::Output *> & values);
 
  std::vector<ExitVar>
  GetExitVars() const;
 
  template<typename F>
  std::vector<Output *>
  GetOutputsWhere(const F & match)
  {
    std::vector<Output *> outputs;
    for (auto & output : Outputs())
    {
      if (match(output))
      {
        outputs.push_back(&output);
      }
    }
 
    return outputs;
  }
 
  ExitVar
  MapOutputExitVar(const rvsdg::Output & output) const;
 
  ExitVar
  MapBranchResultExitVar(const rvsdg::Input & input) const;
 
  const Output &
  mapBranchResultToOutput(const Input & input) const;
 
  Output &
  mapBranchResultToOutput(Input & input) const;
 
  void
  RemoveExitVars(const std::vector<Output *> & gammaOutputs);
 
  void
  RemoveEntryVars(const std::vector<EntryVar> & entryVars);
 
  void
  PruneExitVars()
  {
    const auto deadGammaOutputs = GetOutputsWhere(
        [](const Output & output)
        {
          return output.IsDead();
        });
    RemoveExitVars(deadGammaOutputs);
  }
 
  GammaNode *
  copy(jlm::rvsdg::Region * region, SubstitutionMap & smap) const override;
 
private:
  EntryVar
  GetEntryVar(std::size_t index) const;
 
  std::unique_ptr<GammaOperation> Operation_;
};
 
std::optional<rvsdg::Output *>
GetGammaInvariantOrigin(const GammaNode & gamma, const GammaNode::ExitVar & exitvar);
 
/* gamma node method definitions */
 
inline rvsdg::Input *
GammaNode::predicate() const noexcept
{
  return StructuralNode::input(0);
}
 
bool
ReduceGammaWithStaticallyKnownPredicate(Node & node);
 
bool
ReduceGammaControlConstant(Node & node);
 
bool
ReduceGammaInvariantVariables(Node & node);
 
}
 
#endif