LoadChainSeparation.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Nico Reißmann <nico.reissmann@gmail.com>
 * See COPYING for terms of redistribution.
 */
 
#ifndef JLM_LLVM_OPT_LOADCHAINSEPARATION_HPP
#define JLM_LLVM_OPT_LOADCHAINSEPARATION_HPP
 
#include <jlm/rvsdg/Transformation.hpp>
 
namespace jlm::rvsdg
{
class GammaNode;
class LambdaNode;
class ThetaNode;
}
 
namespace jlm::llvm
{
 
class LoadChainSeparation final : public rvsdg::Transformation
{
  class Context;
 
  // FIXME: I really would like to rename this pass to ReferenceChainSeparation
public:
  ~LoadChainSeparation() noexcept override;
 
  LoadChainSeparation();
 
  LoadChainSeparation(const LoadChainSeparation &) = delete;
 
  LoadChainSeparation &
  operator=(const LoadChainSeparation &) = delete;
 
  void
  Run(rvsdg::RvsdgModule & module, util::StatisticsCollector & statisticsCollector) override;
 
private:
  void
  separateReferenceChainsInRegion(rvsdg::Region & region);
 
  void
  separateReferenceChainsInLambda(rvsdg::LambdaNode & lambdaNode);
 
  void
  separateRefenceChainsInTheta(
      rvsdg::ThetaNode & thetaNode,
      util::HashSet<rvsdg::Output *> & visitedOutputs);
 
  void
  separateRefenceChainsInGamma(rvsdg::GammaNode & gammaNode);
 
  bool
  separateReferenceChains(
      rvsdg::Output & startOutput,
      util::HashSet<rvsdg::Output *> & visitedOutputs);
 
  struct ModRefChainLink
  {
    enum class Type
    {
      Modification,
 
      Reference,
    };
 
    rvsdg::Output * output;
    Type type;
  };
 
  struct ModRefChain
  {
    void
    add(ModRefChainLink modRefChainLink)
    {
      hasModificationChainLink |= modRefChainLink.type == ModRefChainLink::Type::Modification;
      links.push_back(std::move(modRefChainLink));
    }
 
    bool hasModificationChainLink = false;
    std::vector<ModRefChainLink> links{};
  };
 
  struct ModRefChainSummary
  {
    void
    add(ModRefChain modRefChain)
    {
      // We only care about chains that have at least two links
      if (modRefChain.links.size() >= 2)
      {
        modRefChains.push_back(std::move(modRefChain));
      }
 
      hasModificationChainLink |= modRefChain.hasModificationChainLink;
    }
 
    bool hasModificationChainLink = false;
    std::vector<ModRefChain> modRefChains{};
  };
 
  void
  traceModRefChains(
      rvsdg::Output & startOutput,
      util::HashSet<rvsdg::Output *> & visitedOutputs,
      ModRefChainSummary & summary);
 
  static std::vector<ModRefChain>
  extractReferenceSubchains(const ModRefChain & modRefChain);
 
  static rvsdg::Input &
  mapMemoryStateOutputToInput(const rvsdg::Output & output);
 
  std::unique_ptr<Context> Context_{};
};
 
}
 
#endif