lambda.hpp

Go to the documentation of this file.

/*
 * Copyright 2018 Nico Reißmann <nico.reissmann@gmail.com>
 * Copyright 2025 Helge Bahmann <hcb@chaoticmind.net>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_RVSDG_LAMBDA_HPP
#define JLM_RVSDG_LAMBDA_HPP
 
#include <jlm/rvsdg/FunctionType.hpp>
#include <jlm/rvsdg/graph.hpp>
#include <jlm/rvsdg/structural-node.hpp>
#include <jlm/rvsdg/substitution.hpp>
#include <jlm/util/iterator_range.hpp>
 
#include <optional>
#include <utility>
 
namespace jlm::rvsdg
{
 
class LambdaBuilder;
 
class LambdaOperation : public rvsdg::StructuralOperation
{
public:
  ~LambdaOperation() override;
 
  explicit LambdaOperation(std::shared_ptr<const FunctionType> type);
 
  [[nodiscard]] const FunctionType &
  type() const noexcept
  {
    return *type_;
  }
 
  [[nodiscard]] const std::shared_ptr<const FunctionType> &
  Type() const noexcept
  {
    return type_;
  }
 
  [[nodiscard]] std::string
  debug_string() const override;
 
  bool
  operator==(const Operation & other) const noexcept override;
 
  [[nodiscard]] std::unique_ptr<Operation>
  copy() const override;
 
private:
  std::shared_ptr<const FunctionType> type_;
};
 
class LambdaNode final : public rvsdg::StructuralNode
{
public:
  ~LambdaNode() override;
 
private:
  LambdaNode(rvsdg::Region & parent, std::unique_ptr<LambdaOperation> op);
 
public:
  struct ContextVar
  {
    rvsdg::Input * input;
 
    rvsdg::Output * inner;
  };
 
  struct ArgumentVar
  {
    rvsdg::Output * arg;
  };
 
  [[nodiscard]] std::vector<rvsdg::Output *>
  GetFunctionArguments() const;
 
  [[nodiscard]] std::vector<rvsdg::Input *>
  GetFunctionResults() const;
 
  [[nodiscard]] rvsdg::Region *
  subregion() const noexcept
  {
    return StructuralNode::subregion(0);
  }
 
  [[nodiscard]] LambdaOperation &
  GetOperation() const noexcept override;
 
  ContextVar
  AddContextVar(jlm::rvsdg::Output & origin);
 
  [[nodiscard]] ContextVar
  MapInputContextVar(const rvsdg::Input & input) const noexcept;
 
  [[nodiscard]] std::optional<ContextVar>
  MapBinderContextVar(const rvsdg::Output & output) const noexcept;
 
  [[nodiscard]] std::vector<ContextVar>
  GetContextVars() const noexcept;
 
  std::variant<ArgumentVar, ContextVar>
  MapArgument(const rvsdg::Output & output) const;
 
  template<typename F>
  size_t
  RemoveLambdaInputsWhere(const F & match);
 
  size_t
  PruneLambdaInputs()
  {
    auto match = [](const rvsdg::Input &)
    {
      return true;
    };
 
    return RemoveLambdaInputsWhere(match);
  }
 
  [[nodiscard]] rvsdg::Output *
  output() const noexcept;
 
  LambdaNode *
  copy(rvsdg::Region * region, const std::vector<jlm::rvsdg::Output *> & operands) const override;
 
  LambdaNode *
  copy(rvsdg::Region * region, rvsdg::SubstitutionMap & smap) const override;
 
  static LambdaNode *
  Create(rvsdg::Region & parent, std::unique_ptr<LambdaOperation> operation);
 
  rvsdg::Output *
  finalize(const std::vector<jlm::rvsdg::Output *> & results);
 
private:
  std::unique_ptr<LambdaOperation> Operation_;
 
  friend class LambdaBuilder;
};
 
template<typename F>
size_t
LambdaNode::RemoveLambdaInputsWhere(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;
}
 
class LambdaBuilder
{
public:
  LambdaBuilder(Region & region, std::vector<std::shared_ptr<const Type>> argtypes);
 
  std::vector<Output *>
  Arguments();
 
  rvsdg::Region *
  GetRegion() noexcept;
 
  LambdaNode::ContextVar
  AddContextVar(jlm::rvsdg::Output & origin);
 
  Output &
  Finalize(const std::vector<jlm::rvsdg::Output *> & results, std::unique_ptr<LambdaOperation> op);
 
private:
  LambdaNode * Node_;
};
 
[[nodiscard]] rvsdg::LambdaNode &
getSurroundingLambdaNode(rvsdg::Node & node);
 
[[nodiscard]] const rvsdg::LambdaNode &
getSurroundingLambdaNode(const rvsdg::Node & node);
 
}
 
#endif